// ==UserScript==
// @name         麦课刷课助手（视频+图文+极速模式）
// @namespace    http://tampermonkey.net/
// @version 0.1.1
// @description  视频主动触发结束，支持多播放器(XGPlayer/VideoJS/DPlayer/ArtPlayer)，自动翻页，浮动控制面板，兼容验证码页，图文页面优化，统计信息，快捷键支持，page-WH page-video页面支持。已移除 Bootstrap 依赖，完全使用 TDesign（Vue/TDesign 由脚本内动态加载，杜绝 CDN 时序导致的 ref 崩溃）。🚀 新增极速模式：直接调用接口完成课程（15-25秒/课，风险较高，谨慎使用）
// @author       Ethan
// @match        *://weiban.mycourse.cn/*
// @match        *://*.mycourse.cn/*
// @grant        GM_addStyle
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_xmlhttpRequest
// @grant        GM_deleteValue
// @connect      api.mk.heymeta.cn
// @connect      mk.heymeta.cn
// @connect      weiban.mycourse.cn
// @connect      *.mycourse.cn
// @run-at       document-start
// @require      https://cdn.jsdelivr.net/npm/jquery@3.7.1/dist/jquery.slim.min.js
// @require      https://cdn.jsdelivr.net/npm/ajax-hook@2.1.3/dist/ajaxhook.min.js
// @require      https://cdn.jsdelivr.net/npm/@violentmonkey/dom@2.2.1/dist/index.js
// ==/UserScript==

(function() {
    'use strict';

    // ========== wkzy 图文/答题页 item.js 兼容：保证页面 $ 可用 ==========
    // wkzy 图文课件页（/9080/.../item.html + js/item.js）的 item.js 依赖全局 $（jQuery），
    // 当页面自身 jQuery 未加载/加载滞后时会报 "Uncaught ReferenceError: $ is not defined"，
    // 导致整页答题/翻页交互失效。此处把脚本已通过 @require 加载的 jQuery 暴露到页面主世界；
    // 若沙箱内 jQuery 不可用，则用 CDN 同步注入兜底（document.write 阻塞解析，保证 item.js 之前就绪）。
    try {
        var _skPw = (typeof unsafeWindow !== 'undefined') ? unsafeWindow : window;
        if (_skPw && /wkzy\.mycourse\.cn$/i.test(location.hostname) && !_skPw.jQuery) {
            if (window.jQuery) {
                _skPw.$ = _skPw.jQuery = window.jQuery;
            } else {
                document.write('<scr' + 'ipt src="https://cdn.jsdelivr.net/npm/jquery@3.7.1/dist/jquery.min.js"><\/scr' + 'ipt>');
            }
        }
    } catch (_) {}

    // ========== 极早期跨子域桥监听（不依赖任何库/CDN，立即就绪） ==========
    // weiban.mycourse.cn 与 mcwk.mycourse.cn 是不同 origin，localStorage 互不可见。
    // 本监听在脚本一加载就注册，让兄弟子域的隐藏 iframe 能立刻拿到本域快照。
    try {
        if (!window.__sk_bridge_early) {
            window.__sk_bridge_early = true;
            window.addEventListener('message', function (e) {
                try {
                    if (!e.data || typeof e.data !== 'object' || e.data.__sk_bridge_req !== true) return;
                    var snap = { __sk_bridge_resp: true, bank: null, category: null, exam: null, project: null, course: null, user: null };
                    // 题库（平铺 key，跨域可桥）
                    try {
                        var raw = localStorage.getItem('shuake_question_bank_v1');
                        var recs = raw ? JSON.parse(raw) : [];
                        if (Array.isArray(recs) && recs.length > 0) snap.bank = recs.slice(0, 2000);
                    } catch (_) {}
                    // 面板数据（identity 维度：userProjectId/userId/tenantCode 哈希，与 DataCache 一致）
                    try {
                        var p = new URLSearchParams(window.location.search);
                        var hp = null;
                        var h = window.location.hash;
                        if (h && h.indexOf('userProjectId=') >= 0) { try { hp = new URLSearchParams(h.split('?')[1] || ''); } catch (_) {} }
                        var up = (hp && hp.get('userProjectId')) || p.get('userProjectId') || '';
                        var uid = (hp && hp.get('userId')) || p.get('userId') || '';
                        var tc = (hp && hp.get('tenantCode')) || p.get('tenantCode') || '';
                        var base = (up || uid || tc || '');
                        var dim = (base || (window.location.hostname || 'anon'));
                        var hh = 0;
                        for (var i = 0; i < dim.length; i++) { var c = dim.charCodeAt(i); hh = ((hh << 5) - hh) + c; hh = hh & hh; }
                        var id = hh.toString(36);
                        ['category', 'exam', 'project', 'course'].forEach(function (t) {
                            try {
                                var r = localStorage.getItem('shuake_data_v1_' + t + '_' + id);
                                if (r) {
                                    var obj = JSON.parse(r);
                                    if (obj && obj.v != null) snap[t] = obj.v;
                                }
                            } catch (_) {}
                        });
                    } catch (_) {}
                    // 登录态：本域 localStorage['user']（含 token/tenantCode/userId），跨域桥给兄弟域
                    try {
                        var uRaw = localStorage.getItem('user');
                        if (uRaw) {
                            var uObj = JSON.parse(uRaw);
                            if (uObj && typeof uObj === 'object' && (uObj.token || uObj.jwtToken)) snap.user = uObj;
                        }
                    } catch (_) {}
                    if (e.source && typeof e.source.postMessage === 'function') {
                        e.source.postMessage(snap, '*');
                    }
                } catch (_) {}
            });
        }
    } catch (_) {}

    // ========== 早期启动提示 ==========
    console.log('%c[麦课助手] 脚本开始加载...', 'color: #00ff00; font-weight: bold; font-size: 16px');
    console.log('[麦课助手] URL:', window.location.href);
    console.log('[麦课助手] 时间:', new Date().toLocaleString());
    console.log('[麦课助手] 正在等待依赖库加载（Vue、TDesign）...');
    console.log('[麦课助手] 🔍 初始库状态:', {
        jQuery: typeof window.jQuery,
        ah: typeof window.ah,
        VM: typeof window.VM,
        Vue: typeof window.Vue,
        TDesign: typeof window.TDesign
    });
    
    // 手动加载 TDesign CSS
    (function loadTDesignCSS() {
        const link = document.createElement('link');
        link.rel = 'stylesheet';
        link.href = 'https://cdn.jsdelivr.net/npm/tdesign-vue-next@1.10.6/dist/tdesign.min.css';
        link.onload = () => {
            console.log('[麦课助手] TDesign CSS 加载完成');
            console.log('[麦课助手] 📦 CSS加载后库状态:', {
                jQuery: typeof window.jQuery,
                Vue: typeof window.Vue,
                TDesign: typeof window.TDesign
            });
        };
        link.onerror = () => console.error('[麦课助手] TDesign CSS 加载失败');
        (document.head || document.documentElement).appendChild(link);
    })();

    // 创建早期页面提示
    function createEarlyNotice() {
        try {
            const notice = document.createElement('div');
            notice.id = 'shuake-early-notice';
            notice.style.cssText = `
                position: fixed;
                top: 24px;
                right: 24px;
                background: #fff;
                color: rgba(0, 0, 0, 0.9);
                padding: 12px 16px;
                border-radius: 3px;
                font-size: 14px;
                line-height: 22px;
                z-index: 6000;
                box-shadow: 0 3px 14px 2px rgba(0, 0, 0, 0.05), 0 8px 10px 1px rgba(0, 0, 0, 0.06), 0 5px 5px -3px rgba(0, 0, 0, 0.1);
                opacity: 0;
                transition: opacity 0.2s cubic-bezier(0.38, 0, 0.24, 1);
                display: flex;
                align-items: center;
                gap: 8px;
            `;
            notice.innerHTML = `
                <svg width="16" height="16" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="7" stroke="#0052D9" stroke-width="1.5"/><path d="M8 4v5l3 2" stroke="#0052D9" stroke-width="1.5" stroke-linecap="round"/></svg>
                <span>正在加载依赖库...</span>
            `;
            
            if (document.body) {
                document.body.appendChild(notice);
                setTimeout(() => notice.style.opacity = '1', 100);
            } else {
                const observer = new MutationObserver(() => {
                    if (document.body) {
                        document.body.appendChild(notice);
                        setTimeout(() => notice.style.opacity = '1', 100);
                        observer.disconnect();
                    }
                });
                observer.observe(document.documentElement, { childList: true });
            }
        } catch (e) {
            console.warn('[麦课助手] 创建早期提示失败:', e);
        }
    }
    
    // 延迟创建提示，确保 DOM 准备好
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', createEarlyNotice);
    } else {
        createEarlyNotice();
    }

    // ========== 全局错误捕获 ==========
    // 防止单个异常导致整个脚本崩溃
    function safeCall(fn, context = null, ...args) {
        try {
            return fn.apply(context, args);
        } catch (e) {
            console.debug(`[shuake] safeCall 异常: ${e?.message || e}`);
            return undefined;
        }
    }

    function safeAsync(fn, context = null, ...args) {
        return Promise.resolve()
            .then(() => fn.apply(context, args))
            .catch(e => {
                console.debug(`[shuake] safeAsync 异常: ${e?.message || e}`);
                return undefined;
            });
    }

    // 包装 setInterval / setTimeout，统一捕获异常
    function safeInterval(fn, delay) {
        return setInterval(() => safeCall(fn), delay);
    }

    function safeTimeout(fn, delay) {
        return setTimeout(() => safeCall(fn), delay);
    }

    // 安装全局错误监听（最早安装）
    window.addEventListener('error', (e) => {
        try {
            const msg = e?.message || String(e?.error || e);
            const src = e?.filename ? ` @${e.filename}:${e.lineno}` : '';
            
            // 特殊处理 Vue ref 错误
            if (msg.includes("reading 'ref'") || msg.includes("reading 'reactive'")) {
                console.warn('[shuake] ⚠️ Vue 库尚未完全加载，等待中...');
                console.warn('[shuake] 错误详情:', msg + src);
                e.preventDefault(); // 阻止错误冒泡
                return true;
            }
            
            // 特殊处理 Logger TDZ 错误
            if (msg.includes("Cannot access 'Logger' before initialization")) {
                console.warn('[shuake] ⚠️ Logger 初始化顺序问题，已忽略');
                e.preventDefault();
                return true;
            }
            
            console.warn(`[shuake] 全局错误捕获: ${msg}${src}`);
            // 通过全局对象间接访问 Logger，避免 TDZ
            try {
                const L = window.__shuake?.Logger;
                if (L && typeof L.error === 'function') {
                    L.error(`全局错误: ${msg}${src}`);
                }
            } catch (_) {
                console.error('[shuake] global error:', msg, src);
            }
        } catch (_) { /* 静默 */ }
        e.preventDefault?.();
    });

    window.addEventListener('unhandledrejection', (e) => {
        try {
            const reason = e?.reason;
            const msg = (reason && (reason.message || reason.toString())) || 'unknown';
            
            // 特殊处理 Logger TDZ 错误
            if (msg.includes("Cannot access 'Logger' before initialization")) {
                console.warn('[shuake] ⚠️ Logger 初始化顺序问题（Promise），已忽略');
                e.preventDefault();
                return true;
            }

            // 过滤浏览器自动播放拦截（站点自身 play() 未捕获的拒绝，无害但刷屏）：
            // 此时只 console.debug，不再打印 error，避免日志被"play() failed"刷满
            if (/play\(\) failed|NotAllowedError|autoplay|user activation|user gesture/i.test(msg)) {
                try { console.debug('[shuake] 站点自动播放被拦截（已忽略）: ' + msg); } catch (_) {}
                e.preventDefault?.();
                return true;
            }
            
            // 通过全局对象间接访问 Logger，避免 TDZ
            try {
                const L = window.__shuake?.Logger;
                if (L && typeof L.error === 'function') {
                    L.error(`未处理 Promise 异常: ${msg}`);
                } else {
                    console.error('[shuake] unhandled rejection:', msg);
                }
            } catch (_) {
                console.error('[shuake] unhandled rejection:', msg);
            }
        } catch (_) { /* 静默 */ }
        e.preventDefault?.();
    });

    // ========== 安全 JSON 解析 ==========
    const SafeJSON = {
        parse(text, fallback = null) {
            if (text == null) return fallback;
            if (typeof text !== 'string') return text; // 非字符串：直接原样返回（兼容性）
            const trimmed = text.trim();
            // 空字符串 / 空白 → 视为无内容，不打"失败"日志（404/重定向常返回空 body）
            if (trimmed.length === 0) return fallback;
            // 单一 JSON 值不会以 '<' 开头；大概率是 HTML 错误页：静默返回 fallback
            if (trimmed.startsWith('<') || trimmed.startsWith('<!')) return fallback;
            try {
                return JSON.parse(trimmed);
            } catch (e) {
                // 仅"明显长得像 JSON"（{ [ " 数字 true/false/null 开头）的才打日志；否则静默
                const first = trimmed.charAt(0);
                if ('{"[\'-0123456789tfn'.includes(first)) {
                    try { console.debug('[shuake] JSON 解析失败: ' + (e && e.message ? e.message : String(e)) + '（首段=' + trimmed.slice(0, 40) + '）'); } catch (_) {}
                }
                return fallback;
            }
        },
        stringify(obj, fallback = '{}') {
            try {
                return JSON.stringify(obj);
            } catch (e) {
                console.debug(`[shuake] JSON 序列化失败: ${e.message}`);
                return fallback;
            }
        }
    };

    // ========== HTML 转义工具 ==========
    // 用于在面板中通过 innerHTML 渲染用户/AI 文本时防止 XSS
    function escapeHtml(text) {
        if (text == null) return '';
        return String(text)
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;')
            .replace(/'/g, '&#39;');
    }

    // ========== 第三方库加载检测 ==========
    // 包装对 jQuery / ajax-hook / @violentmonkey/dom / Vue / TDesign 的访问
    // 这些库通过 @require 由脚本管理器加载，但加载可能因 CDN 故障而失败
    // 此处提供统一的检测与降级，确保脚本在库未加载时仍能工作
    const Libs = {
        // 内部就绪状态
        _ready: false,
        _jquery: null,
        _ajaxhook: null,
        _vmdom: null,
        _vue: null,
        _tdesign: null,

        init() {
            try {
                this._jquery = (typeof window !== 'undefined' && window.jQuery) ? window.jQuery : null;
                this._ajaxhook = (typeof window !== 'undefined' && window.ah) ? window.ah : null;
                this._vmdom = (typeof window !== 'undefined' && window.VM) ? window.VM : null;
                
                // 优先使用稳定引用（防止 window.Vue/TDesign 被页面代码覆盖）
                this._vue = _sandboxVueRef || ((typeof window !== 'undefined' && window.Vue) ? window.Vue : null);
                this._tdesign = _sandboxTDRef || ((typeof window !== 'undefined' && window.TDesign) ? window.TDesign : null);
                
                // 如果稳定引用存在但 window 上的丢失了，恢复它（确保 TDesign 组件能访问）
                if (this._vue && typeof window !== 'undefined' && !window.Vue) {
                    window.Vue = this._vue;
                    console.log('[shuake] 🔄 window.Vue 已从稳定引用恢复');
                }
                if (this._tdesign && typeof window !== 'undefined' && !window.TDesign) {
                    window.TDesign = this._tdesign;
                    console.log('[shuake] 🔄 window.TDesign 已从稳定引用恢复');
                }
                
                this._ready = true;

                // 【课程名跨域存储】weiban 域课程详情页 URL 带 courseName（#/course/detail?courseName=...），
                // 而图文/视频课件页（mcwk 域 iframe）URL 不携带。此处解析并存到 GM 存储，
                // 课件页上报（StudyReporter.report 兜底）读取同 key，保证 completed 记录课程名不落空。
                try {
                    let _cn = '';
                    try {
                        const _h = (typeof location !== 'undefined' && location.hash) || '';
                        const _qi = _h.indexOf('?');
                        if (_qi >= 0) _cn = new URLSearchParams(_h.slice(_qi + 1)).get('courseName') || '';
                    } catch (_) {}
                    if (!_cn) {
                        try { _cn = new URLSearchParams((typeof location !== 'undefined' && location.search) || '').get('courseName') || ''; } catch (_) {}
                    }
                    if (_cn) {
                        try { _cn = decodeURIComponent(_cn); } catch (_) {}
                        if (_cn && _cn !== 'undefined') {
                            try { if (typeof GM_setValue === 'function') GM_setValue('sk_course_name', _cn); } catch (_) {}
                            try { State.currentCourseName = _cn; } catch (_) {}
                        }
                    }
                } catch (_) {}

                // 【课程名·iframe src 兜底】宿主页 URL 无 courseName 参数时，从 page-iframe src 解析 courseId，
                // 调站点 listCourse.do（GM_xmlhttpRequest 跨域）匹配课程名 → GM 存储，供课件页上报兜底读取。
                if (!_cn) {
                    try {
                        let _cid = '';
                        try {
                            const _if = document.querySelector('iframe.page-iframe, iframe[src*="mcwk"], iframe[src*="course/"]');
                            if (_if && _if.src) {
                                try { _cid = new URL(_if.src).searchParams.get('courseId') || ''; } catch (_) {}
                            }
                        } catch (_) {}
                        if (_cid) {
                            (async () => {
                                try {
                                    if (typeof StudyAssistant !== 'undefined' && typeof StudyAssistant.fetchCourses === 'function') {
                                        const _list = await StudyAssistant.fetchCourses();
                                        const _m = (Array.isArray(_list) ? _list : []).find((c) => (c.resourceId && c.resourceId === _cid) || (c.courseId && c.courseId === _cid));
                                        if (_m && _m.resourceName) {
                                            try { if (typeof GM_setValue === 'function') GM_setValue('sk_course_name', _m.resourceName); } catch (_) {}
                                            try { State.currentCourseName = _m.resourceName; } catch (_) {}
                                        }
                                    }
                                } catch (_) {}
                            })();
                        }
                    } catch (_) {}
                }

                const available = {
                    jquery: !!this._jquery,
                    ajaxhook: !!this._ajaxhook,
                    vmdom: !!this._vmdom,
                    vue: !!this._vue,
                    tdesign: !!this._tdesign
                };
                
                console.log('[shuake] 🔍 Library loading status:', available);
                
                // 详细检测 Vue API
                if (this._vue) {
                    console.log('[shuake] ✅ Vue detected:', {
                        hasRef: typeof this._vue?.ref === 'function',
                        hasReactive: typeof this._vue?.reactive === 'function',
                        hasCreateApp: typeof this._vue?.createApp === 'function'
                    });
                } else {
                    console.warn('[shuake] ⚠️ Vue is not available on window.Vue');
                }
                
                // 注意：直接引用 `Logger` 在 const TDZ 期间会抛 ReferenceError
                // 即使 `typeof Logger` 在 TDZ 也会抛错，必须通过 window.__shuake.Logger 间接访问
                try {
                    const L = (typeof window !== 'undefined' && window.__shuake && window.__shuake.Logger) || null;
                    if (L && typeof L.info === 'function') {
                        L.info(`第三方库加载状态: ${JSON.stringify(available)}`);
                    }
                } catch (_) { /* Logger 尚未初始化时静默 */ }
            } catch (e) {
                console.error('[Libs] 检测失败:', e);
            }
        },

        get $() {
            // 实时检测，不依赖缓存
            if (!this._jquery && typeof window !== 'undefined' && window.jQuery) {
                this._jquery = window.jQuery;
            }
            return this._jquery || null;
        },

        get ah() {
            if (!this._ajaxhook && typeof window !== 'undefined' && window.ah) {
                this._ajaxhook = window.ah;
            }
            return this._ajaxhook || null;
        },

        get VM() {
            if (!this._vmdom && typeof window !== 'undefined' && window.VM) {
                this._vmdom = window.VM;
            }
            return this._vmdom || null;
        },

        get Vue() {
            // 实时检测 Vue，不依赖初始化时的缓存
            // 防御：如果缓存失效，尝试从 window 重新获取
            if (!this._vue && typeof window !== 'undefined' && window.Vue) {
                this._vue = window.Vue;
                console.log('[shuake] ✅ Vue loaded dynamically');
            }
            // 二次防御：如果 window.Vue 也丢失了，尝试从 unsafeWindow 恢复
            if (!this._vue && typeof unsafeWindow !== 'undefined' && unsafeWindow && unsafeWindow.Vue) {
                this._vue = unsafeWindow.Vue;
                // 同时恢复到 window，确保 TDesign 组件能访问
                if (typeof window !== 'undefined') {
                    window.Vue = this._vue;
                }
                console.log('[shuake] 🔄 Vue recovered from unsafeWindow');
            }
            return this._vue || null;
        },

        get TDesign() {
            // 实时检测 TDesign
            if (!this._tdesign && typeof window !== 'undefined' && window.TDesign) {
                this._tdesign = window.TDesign;
                console.log('[shuake] ✅ TDesign loaded dynamically');
            }
            // 二次防御：从 unsafeWindow 恢复
            if (!this._tdesign && typeof unsafeWindow !== 'undefined' && unsafeWindow && unsafeWindow.TDesign) {
                this._tdesign = unsafeWindow.TDesign;
                if (typeof window !== 'undefined') {
                    window.TDesign = this._tdesign;
                }
                console.log('[shuake] 🔄 TDesign recovered from unsafeWindow');
            }
            return this._tdesign || null;
        },

        // 库是否就绪的便捷检查
        get hasJQuery() { return !!this.$; },
        get hasAjaxHook() { return !!this.ah; },
        get hasVMDom() { return !!this.VM; },
        get hasVue() { return !!this.Vue; },
        get hasTDesign() {
            return !!this.TDesign;
        },
        get hasVuePanel() {
            // Vue 面板可用：Vue 必须就绪，且 TDesign 全局 API 暴露（tdesign-vue-next 全局构建会挂 window.TDesign）
            return !!(this.Vue && this.TDesign);
        }
    };

    // ========== TDesign 样式加载器 ==========
    // 设计目标：
    //   1. 仅注入面板所需的 TDesign CSS（按需）
    //   2. CDN 失败时静默降级
    //   3. 所有 TDesign 类名前缀隔离为 t-，通过 #shuake-panel 子树限定作用域
    const TDesignLoader = {
        CSS_URL: 'https://cdn.jsdelivr.net/npm/tdesign-vue-next@1.10.6/dist/tdesign.css',
        _cssInjected: false,

        ensureCSS() {
            if (this._cssInjected) return true;
            if (document.querySelector('link[data-shuake-td-css]')) {
                this._cssInjected = true;
                return true;
            }
            const link = document.createElement('link');
            link.rel = 'stylesheet';
            link.href = this.CSS_URL;
            link.dataset.shuakeTdCss = '1';
            link.crossOrigin = 'anonymous';
            link.onload = () => { this._cssInjected = true; };
            link.onerror = () => {
                try { console.warn('[shuake] TDesign CSS 加载失败，将降级使用原生样式'); } catch (_) {}
            };
            (document.head || document.documentElement).appendChild(link);
            this._cssInjected = true;
            return true;
        },

        get isCSSReady() { return this._cssInjected; }
    };

    // 安全的样式注入：优先 GM_addStyle，缺失时退回 DOM <style>（避免部分管理器导致脚本静默死亡）
    function injectStyle(css) {
        try {
            if (typeof GM_addStyle === 'function') { GM_addStyle(css); return; }
        } catch (_) {}
        try {
            const s = document.createElement('style');
            s.textContent = css;
            (document.head || document.documentElement).appendChild(s);
        } catch (_) {}
    }

    // TDesign 样式作用域：仅在 #shuake-panel 子树内生效
    // 通过 CSS 后代选择器限定，避免污染宿主页
    injectStyle(`
        /* TDesign 样式作用域 —— 锁定在 #shuake-panel 子树 */
        /* TDesign 默认会将组件挂到全局，因此需要把它的样式作用域严格限定在面板内 */
        /* 由于 TDesign CSS 用 .t- 前缀，我们重写为 #shuake-panel .t-* 的子作用域模式 */
        #shuake-panel { color: #1d1d1f; font-family: -apple-system, BlinkMacSystemFont, 'SF Pro Display', 'SF Pro Text', 'Helvetica Neue', sans-serif; }
        #shuake-panel .t-button { transition: all 0.2s cubic-bezier(0.25, 0.1, 0.25, 1); }
        #shuake-panel .t-tabs__nav-item { font-size: 12px; }
        #shuake-panel .t-input { font-size: 12px; }
        #shuake-panel .t-textarea { font-size: 12px; }
        #shuake-panel .t-tag { font-size: 10px; }
        #shuake-panel .t-switch { transform: scale(0.85); }
        /* TDesign 默认浮层 z-index 999，需要让面板内的弹层在面板之上 */
        #shuake-panel .t-popup { z-index: 1000000; }
        /* TDesign Tooltip 在面板内可正常显示 */
        #shuake-panel .t-tooltip { z-index: 1000000; }
    `);

    // ========== TDesign UI 组件封装 ==========
    // 完全移除 Bootstrap 依赖，统一使用 TDesign 组件
    // 设计目标：
    //   1. 不污染宿主页样式 —— 所有 TDesign 样式只作用在 #shuake-panel 子树内
    //   2. 组件 API 统一出口（toast / confirm / tooltip）
    //   3. 优雅降级 —— TDesign 未加载时降级到原生 UI

    // TDesign 样式作用域：仅在面板内启用
    injectStyle(`
        /* TDesign 样式作用域隔离 —— 锁定在 #shuake-panel 子树 */
        #shuake-panel,
        #shuake-panel *,
        #shuake-panel *::before,
        #shuake-panel *::after {
            box-sizing: border-box;
        }
        #shuake-panel {
            font-family: -apple-system, BlinkMacSystemFont, 'SF Pro Display', 'SF Pro Text', 'Helvetica Neue', sans-serif;
            line-height: 1.5;
            color: #1d1d1f;
        }
    `);

    // TDesign 组件封装
    const ShuaKeUI = {
        // Toast：使用 TDesign Message 组件
        toast(message, variant = 'info', duration = 3000) {
            if (!window.TDesign?.MessagePlugin) {
                console.warn('[shuake] TDesign MessagePlugin 未加载，降级到 console');
                console.log(`[shuake] ${message}`);
                return;
            }
            
            const typeMap = {
                'primary': 'info',
                'success': 'success',
                'danger': 'error',
                'warning': 'warning',
                'info': 'info'
            };
            
            const type = typeMap[variant] || 'info';
            window.TDesign.MessagePlugin[type](String(message ?? ''), duration);
        },

        // Confirm：使用 TDesign Dialog 组件
        confirm(message, opts = {}) {
            return new Promise((resolve) => {
                if (!window.TDesign?.DialogPlugin) {
                    console.warn('[shuake] TDesign DialogPlugin 未加载，降级到原生 confirm');
                    resolve(window.confirm(message));
                    return;
                }
                
                const { 
                    title = '确认', 
                    confirmText = '确定', 
                    cancelText = '取消', 
                    variant = 'warning' 
                } = opts;
                
                const themeMap = {
                    'danger': 'warning',
                    'warning': 'warning',
                    'info': 'info',
                    'primary': 'info'
                };
                
                const dialog = window.TDesign.DialogPlugin.confirm({
                    header: title,
                    body: message,
                    confirmBtn: confirmText,
                    cancelBtn: cancelText,
                    theme: themeMap[variant] || 'info',
                    onConfirm: () => {
                        dialog.hide();
                        resolve(true);
                    },
                    onCancel: () => {
                        dialog.hide();
                        resolve(false);
                    },
                    onClose: () => {
                        resolve(false);
                    }
                });
            });
        },

        // Tooltip：简单的 title 实现（TDesign Tooltip 通常通过 Vue 指令使用）
        enableTooltip(el, title, placement = 'top') {
            if (!el || !title) return null;
            el.title = title;
            return null;
        },

        // Prompt：带输入框的对话框（TDesign DialogPlugin + 原生 input）。
        // 用于"修改题库答案"等需要用户输入文本的场景。
        // 返回 Promise<{ ok: boolean, value: string }>：ok=true 表示用户确认。
        prompt(message, opts = {}) {
            return new Promise((resolve) => {
                const { title = '输入', defaultValue = '', placeholder = '', confirmText = '确定', cancelText = '取消' } = opts;
                if (!window.TDesign?.DialogPlugin) {
                    // 降级到原生 prompt（部分老浏览器安全策略下会返回 null）
                    const val = window.prompt(message, defaultValue);
                    resolve({ ok: typeof val === 'string', value: val || '' });
                    return;
                }
                // DialogPlugin 返回对象不含 querySelector，需通过全局 document 查 DOM。
                // body 容器实际类名为 .t-dialog__body__icon（TDesign 1.10.6）。
                let confirmBtn = null;
                const dialog = window.TDesign.DialogPlugin({
                    header: title,
                    body: message,
                    confirmBtn: confirmText,
                    cancelBtn: cancelText,
                    theme: 'info',
                    onConfirm: () => {
                        try {
                            const input = document.querySelector('.t-dialog .sk-prompt-input');
                            const val = input ? input.value : '';
                            dialog.hide();
                            resolve({ ok: true, value: String(val || '').trim() });
                        } catch (_) {
                            dialog.hide();
                            resolve({ ok: false, value: '' });
                        }
                    },
                    onCancel: () => {
                        dialog.hide();
                        resolve({ ok: false, value: '' });
                    },
                    onClose: () => {
                        resolve({ ok: false, value: '' });
                    }
                });
                // 注入输入框到对话框正文
                try {
                    const bodyEl = document.querySelector('.t-dialog .t-dialog__body__icon');
                    if (bodyEl) {
                        const input = document.createElement('input');
                        input.type = 'text';
                        input.value = String(defaultValue || '');
                        input.placeholder = String(placeholder || '');
                        input.className = 'sk-prompt-input';
                        input.style.cssText = 'width:100%;box-sizing:border-box;padding:6px 10px;font-size:12px;border:1px solid rgba(0,0,0,0.12);border-radius:6px;outline:none;margin-top:4px;';
                        input.addEventListener('keydown', (e) => {
                            if (e.key === 'Enter') {
                                e.preventDefault();
                                const okBtn = document.querySelector('.t-dialog .t-button--theme-primary');
                                if (okBtn) okBtn.click();
                            }
                        });
                        bodyEl.appendChild(input);
                        setTimeout(() => { try { input.focus(); input.select(); } catch (_) {} }, 50);
                    }
                } catch (_) {}
            });
        }
    };

    // 暴露到 window，方便控制台测试与外部模块调用（与文档一致）
    try { window.ShuaKeUI = ShuaKeUI; } catch (_) {}
    
    // 调试辅助：暴露稳定引用状态（生产环境可通过 console 检查）
    try {
        if (typeof window !== 'undefined') {
            window.__shuake_debug = window.__shuake_debug || {};
            Object.defineProperty(window.__shuake_debug, 'libRefs', {
                get: () => ({
                    sandboxVueRef: _sandboxVueRef,
                    sandboxTDRef: _sandboxTDRef,
                    windowVue: window.Vue,
                    windowTDesign: window.TDesign,
                    unsafeVue: (typeof unsafeWindow !== 'undefined' && unsafeWindow) ? unsafeWindow.Vue : undefined,
                    unsafeTDesign: (typeof unsafeWindow !== 'undefined' && unsafeWindow) ? unsafeWindow.TDesign : undefined
                })
            });
        }
    } catch (_) {}

    // ========== 动态库加载器 ==========
    // 设计目标：
    //   1. Vue / TDesign 不再依赖 @require —— 避免 CDN 时序问题导致 TDesign 在 Vue 缺失时
    //      执行 UMD 工厂直接抛 "Cannot read properties of undefined (reading 'ref')" 崩溃
    //   2. 严格按顺序加载：先 Vue 后 TDesign；Vue 失败则不加载 TDesign（绝不再触发 ref 崩溃）
    //   3. 多 CDN 备用源 + 清晰的失败日志，失败时由 waitForLibraries 走降级模式
    //   4. 【关键修复】保持稳定引用：TDesign UMD 可能在运行时访问全局 window.Vue，
    //      必须确保沙箱 window.Vue 在整个生命周期保持可用（不被页面代码覆盖或清除）
    const LIB_CDN_FALLBACKS = {
        vue: [
            'https://cdn.jsdelivr.net/npm/vue@3.5.13/dist/vue.global.prod.js',
            'https://unpkg.com/vue@3.5.13/dist/vue.global.prod.js',
            'https://cdn.bootcdn.net/ajax/libs/vue/3.5.13/vue.global.prod.min.js'
        ],
        tdesign: [
            'https://cdn.jsdelivr.net/npm/tdesign-vue-next@1.10.6/dist/tdesign.min.js',
            'https://unpkg.com/tdesign-vue-next@1.10.6/dist/tdesign.min.js'
        ]
    };

    // 动态注入 <script>，返回 Promise
    function loadScript(src, timeout = 20000) {
        return new Promise((resolve, reject) => {
            try {
                if (typeof document === 'undefined' || typeof document.createElement !== 'function') {
                    reject(new Error('document 不可用'));
                    return;
                }
                const s = document.createElement('script');
                s.src = src;
                s.crossOrigin = 'anonymous';
                const timer = setTimeout(() => { reject(new Error('加载超时: ' + src)); }, timeout);
                s.onload = () => { clearTimeout(timer); resolve(); };
                s.onerror = () => { clearTimeout(timer); reject(new Error('加载失败: ' + src)); };
                (document.head || document.documentElement).appendChild(s);
            } catch (e) {
                reject(e);
            }
        });
    }

    // kind -> 全局变量名映射（Vue/TDesign 都是大写开头）
    const LIB_GLOBAL = { vue: 'Vue', tdesign: 'TDesign' };

    // 动态加载的脚本在页面主世界执行；若沙箱 window 看不到，则从 unsafeWindow 同步过来
    function syncGlobal(kind) {
        const globalName = LIB_GLOBAL[kind] || kind;
        try {
            if (window[globalName]) return true;
            if (typeof unsafeWindow !== 'undefined' && unsafeWindow && unsafeWindow[globalName]) {
                window[globalName] = unsafeWindow[globalName];
                return true;
            }
        } catch (_) {}
        return !!window[globalName];
    }

    // 页面浮动 Toast（不依赖 TDesign，任何时刻可用）；用于快捷键反馈与接口自动刷课提示
    let _skToastTimer = null;
    function showFloatToast(message, type = 'info', duration = 2200) {
        try {
            let el = document.getElementById('shuake-float-toast');
            if (!el) {
                el = document.createElement('div');
                el.id = 'shuake-float-toast';
                el.style.cssText = 'position:fixed;top:74px;right:22px;z-index:9999999;max-width:280px;padding:9px 14px;border-radius:10px;background:rgba(20,20,20,0.88);color:#fff;font-size:12px;line-height:1.5;box-shadow:0 4px 18px rgba(0,0,0,0.25);backdrop-filter:blur(8px);opacity:0;transform:translateY(-6px);transition:opacity .22s,transform .22s;pointer-events:none;font-family:-apple-system,BlinkMacSystemFont,"Helvetica Neue",sans-serif;white-space:pre-wrap;';
                (document.body || document.documentElement).appendChild(el);
            }
            const colorMap = { success: '#34c759', warning: '#ff9500', danger: '#ff3b30', info: '#0a84ff' };
            el.style.borderLeft = `3px solid ${colorMap[type] || '#0a84ff'}`;
            el.textContent = String(message ?? '');
            el.style.opacity = '1';
            el.style.transform = 'translateY(0)';
            if (_skToastTimer) { clearTimeout(_skToastTimer); }
            _skToastTimer = setTimeout(() => {
                el.style.opacity = '0';
                el.style.transform = 'translateY(-6px)';
            }, duration);
        } catch (_) {}
    }

    // 带备用源加载一类库（vue / tdesign），已存在则直接成功
    // deferRestore=true（仅 vue）：不立即还原主世界全局，保留 window.Vue 供随后的 TDesign UMD
    // 求值使用（tdesign.min.js 是 t((globalThis.TDesign={}), globalThis.Vue)，若 Vue 已被删则工厂
    // 在 Vue.ref 处抛错，TDesign 只剩空壳 {}，面板组件全部失效）。由 restoreMainVue() 统一还原。
    let _mainVueBackup = null;   // 待还原的主世界 Vue（{hadPrev, prevVal}），幂等
    let _sandboxVueRef = null;   // 沙箱 window.Vue 的稳定引用，防止被页面代码覆盖
    let _sandboxTDRef = null;    // 沙箱 window.TDesign 的稳定引用
    async function loadLibWithFallback(kind, deferRestore) {
        console.log(`[麦课助手] 📦 loadLibWithFallback('${kind}') 开始`);
        const globalName = LIB_GLOBAL[kind] || kind;
        // 沙箱里已有我们自己的副本 → 直接成功，不触碰页面全局
        if (window[globalName]) {
            try { console.log(`[麦课助手] ✅ ${kind} 已就绪（沙箱缓存，跳过动态加载）`); } catch (_) {}
            // 保存稳定引用
            if (kind === 'vue') _sandboxVueRef = window.Vue;
            if (kind === 'tdesign') _sandboxTDRef = window.TDesign;
            return true;
        }
        // 记录页面主世界该全局的原始值；加载后要恢复，避免污染站点。
        // 背景：weiban 站点打包了 Vue3 与 Vue2 的 mint-ui，mint-ui 在 vendor.js 求值时
        // 若发现 window.Vue 存在会立即执行 Vue2 的 t.component(...) 安装，被我们的 Vue3
        // 覆盖后抛 "Uncaught TypeError: t.component is not a function"，整站 UI 崩溃。
        const pw = (typeof unsafeWindow !== 'undefined' && unsafeWindow) ? unsafeWindow : null;
        let prevVal, hadPrev = false;
        try {
            if (pw && typeof pw[globalName] !== 'undefined') { prevVal = pw[globalName]; hadPrev = true; }
        } catch (_) {}
        const urls = LIB_CDN_FALLBACKS[kind] || [];
        console.log(`[麦课助手] 📋 ${kind} 备用源列表:`, urls);
        for (let i = 0; i < urls.length; i++) {
            const url = urls[i];
            try {
                console.log(`[麦课助手] 🔽 动态加载 ${kind} [${i+1}/${urls.length}]:`, url);
                await loadScript(url);
                console.log(`[麦课助手] ✓ ${kind} 脚本加载完成，检查全局对象...`);
                if (syncGlobal(kind)) {
                    // 保存沙箱的稳定引用（防止后续被页面代码覆盖）
                    if (kind === 'vue') _sandboxVueRef = window.Vue;
                    if (kind === 'tdesign') _sandboxTDRef = window.TDesign;
                    
                    // 关键：立即把页面主世界的同名全局恢复原状（原本不存在则删除）。
                    // 沙箱 window 已保留我们自己的副本供面板使用，页面不再被污染。
                    try {
                        if (pw) {
                            if (deferRestore) {
                                // 延迟还原：记录待还原状态，保留主世界 Vue 供 TDesign 求值
                                _mainVueBackup = { hadPrev, prevVal, pw };
                            } else {
                                if (hadPrev) pw[globalName] = prevVal;
                                else { try { delete pw[globalName]; } catch (_) { pw[globalName] = undefined; } }
                            }
                        }
                    } catch (_) {}
                    console.log(`[麦课助手] ✅ ${kind} 动态加载成功，全局对象已就绪${deferRestore ? '（主世界暂留待还原）' : '（页面全局已还原）'}`);
                    return true;
                } else {
                    console.warn(`[麦课助手] ⚠️ ${kind} 脚本加载完成但全局对象未找到`);
                }
            } catch (e) {
                try { console.warn(`[麦课助手] ⚠️ ${kind} 加载失败（尝试备用源）: ${e.message}`); } catch (_) {}
            }
        }
        try { console.warn(`[麦课助手] ⚠️ ${kind} 所有 CDN 均加载失败，将使用降级模式`); } catch (_) {}
        return false;
    }

    // 还原主世界 Vue（延迟到 TDesign 加载完成后执行；幂等）
    // 注意：只还原 unsafeWindow（页面主世界），不动沙箱 window.Vue
    // TDesign UMD 在初始化时可能存储了对全局 Vue 的引用，必须保持 window.Vue 可用
    function restoreMainVue() {
        try {
            if (!_mainVueBackup) return;
            const { hadPrev, prevVal, pw } = _mainVueBackup;
            _mainVueBackup = null;
            if (!pw) return;
            if (hadPrev) pw.Vue = prevVal;
            else { try { delete pw.Vue; } catch (_) { pw.Vue = undefined; } }
            
            // 关键修复：确保沙箱 window.Vue 保持我们的版本，不被页面覆盖
            // 使用稳定引用恢复（防止 TDesign 组件渲染时访问到 undefined）
            if (_sandboxVueRef && typeof window !== 'undefined') {
                window.Vue = _sandboxVueRef;
            }
            if (_sandboxTDRef && typeof window !== 'undefined') {
                window.TDesign = _sandboxTDRef;
            }
            
            try { console.log('[麦课助手] ✅ 主世界 Vue 已还原（沙箱 window.Vue 保持不变）'); } catch (_) {}
        } catch (_) {}
    }

    // 确保 Vue、TDesign 就绪（严格顺序：先 Vue 后 TDesign）
    async function ensureVueAndTDesign() {
        console.log('[麦课助手] 🚀 ensureVueAndTDesign() 开始执行');
        console.log('[麦课助手] 📊 加载前状态:', {
            Vue: typeof window.Vue,
            TDesign: typeof window.TDesign
        });
        
        const vueOk = await loadLibWithFallback('vue', true);   // deferRestore：保留主世界 Vue 供 TDesign 求值
        console.log('[麦课助手] Vue 加载结果:', vueOk);
        
        if (!vueOk) {
            console.log('[麦课助手] ❌ Vue 加载失败，跳过 TDesign');
            return { vue: false, tdesign: false };
        }
        
        const tdOk = await loadLibWithFallback('tdesign');
        console.log('[麦课助手] TDesign 加载结果:', tdOk);
        // 两库均加载完成后，统一还原主世界 Vue（TDesign UMD 求值已结束，不再需要它）
        restoreMainVue();
        console.log('[麦课助手] 📊 加载后状态:', {
            Vue: typeof window.Vue,
            TDesign: typeof window.TDesign
        });
        
        return { vue: true, tdesign: tdOk };
    }

    // 等待 @require 库加载完成
    // @require 脚本是异步加载的，需要等待它们挂载到 window 对象上
    function waitForLibraries(callback, timeout = 20000) {
        console.log('[麦课助手] 🔍 waitForLibraries() 开始');
        // 主动触发 Vue/TDesign 动态加载（幂等：已存在则跳过）
        ensureVueAndTDesign().then((res) => {
            console.log('[麦课助手] 📦 ensureVueAndTDesign 完成:', res);
            try {
                if (!res.vue) console.warn('[麦课助手] Vue 加载失败，进入降级模式');
                else if (!res.tdesign) console.warn('[麦课助手] TDesign 加载失败，面板将使用降级样式');
                else console.log('[麦课助手] ✅ Vue 和 TDesign 都已成功加载');
            } catch (_) {}
        }).catch((e) => {
            try { console.warn('[麦课助手] 动态加载异常:', e?.message || e); } catch (_) {}
        });
        const startTime = Date.now();
        const checkInterval = 100;
        let lastLogTime = 0;
        
        console.log('[麦课助手] waitForLibraries 开始等待，超时时间:', timeout + 'ms');
        
        function check() {
            const elapsed = Date.now() - startTime;
            const vueReady = !!(typeof window !== 'undefined' && window.Vue);
            const tdesignReady = !!(typeof window !== 'undefined' && window.TDesign);
            const jqueryReady = !!(typeof window !== 'undefined' && window.jQuery);
            const ajaxhookReady = !!(typeof window !== 'undefined' && window.ah);
            
            // 每秒输出一次等待状态
            if (elapsed - lastLogTime > 1000) {
                console.log('[麦课助手] ⏳ 等待库加载...', {
                    elapsed: `${(elapsed / 1000).toFixed(1)}s`,
                    vue: vueReady,
                    tdesign: tdesignReady,
                    jquery: jqueryReady,
                    ajaxhook: ajaxhookReady
                });
                lastLogTime = elapsed;
            }
            
            // 检查 Vue API 是否完整
            const vueComplete = vueReady && 
                typeof window.Vue?.ref === 'function' &&
                typeof window.Vue?.reactive === 'function' &&
                typeof window.Vue?.createApp === 'function';
            
            if (vueComplete && tdesignReady) {
                console.log('%c[麦课助手] ✅ Vue 和 TDesign 已就绪', 'color: #4CAF50; font-weight: bold');
                console.log('[麦课助手] 🔍 Vue 版本检测:', {
                    ref: typeof window.Vue?.ref,
                    reactive: typeof window.Vue?.reactive,
                    createApp: typeof window.Vue?.createApp
                });
                
                // 更新页面提示
                try {
                    const notice = document.getElementById('shuake-early-notice');
                    if (notice) {
                        notice.innerHTML = `
                            <svg width="16" height="16" viewBox="0 0 16 16" fill="none"><path d="M13.7 4.3l-6.4 6.4-2.6-2.6" stroke="#00A870" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>
                            <span>已就绪，正在初始化...</span>
                        `;
                        // 3秒后淡出
                        setTimeout(() => {
                            notice.style.opacity = '0';
                            setTimeout(() => notice.remove(), 500);
                        }, 3000);
                    }
                } catch (_) {}
                
                Libs.init();
                callback();
                return;
            }
            
            if (elapsed > timeout) {
                console.warn('%c[麦课助手] ⚠️ Vue/TDesign 加载超时，将使用降级模式', 'color: #ff9800; font-weight: bold');
                console.log('[麦课助手] 当前状态:', { 
                    vue: vueReady,
                    vueComplete: vueComplete,
                    tdesign: tdesignReady,
                    jquery: jqueryReady,
                    ajaxhook: ajaxhookReady
                });
                console.warn('[麦课助手] 💡 提示: @require 的 CDN 可能加载失败，请检查网络或 Tampermonkey 设置');
                
                // 更新页面提示
                try {
                    const notice = document.getElementById('shuake-early-notice');
                    if (notice) {
                        notice.innerHTML = `
                            <div style="font-weight: bold; margin-bottom: 4px;">⚠️ 麦课刷课助手</div>
                            <div style="font-size: 11px; opacity: 0.9;">依赖库加载失败，使用降级模式</div>
                        `;
                        notice.style.background = 'linear-gradient(135deg, #ff9800 0%, #ff5722 100%)';
                    }
                } catch (_) {}
                
                Libs.init();
                callback();
                return;
            }
            
            setTimeout(check, checkInterval);
        }
        
        check();
    }
    
    // 同步初始化基础库（兜底） — jQuery 和 ajax-hook 通常立即可用
    try {
        Libs._jquery = (typeof window !== 'undefined' && window.jQuery) ? window.jQuery : null;
        Libs._ajaxhook = (typeof window !== 'undefined' && window.ah) ? window.ah : null;
        Libs._vmdom = (typeof window !== 'undefined' && window.VM) ? window.VM : null;
    } catch (_) {}

    // ========== 配置区 ==========
    const DEFAULT_SYSTEM_PROMPT = '你是一个选择题答题助手。请根据题目内容，选择最正确的答案。\n\n题目：{question}\n\n选项：\n{options}\n\n请直接回答选项字母（A/B/C/D），不需要解释。如果有多个正确答案，请用逗号分隔（如：A,B）。';

    const CONFIG = {
        checkInterval: 1200,        // 检测间隔(ms)
        progressThreshold: 1.0,     // 进度完成阈值(0-1)：必须 100% 完整完成才算完成
        injectDelay: 1000,          // inject延迟(ms)
        pageTurnDelay: 500,         // 翻页后延迟(ms)
        triggerClickCooldown: 3000, // 逐一点击触发器的最小间隔(ms)：grid 逐格显示依赖此间隔，过快站点只响应第一格
        maxRetryAttempts: 5,        // 最大重试次数
        enablePanel: true,         // 启用控制面板
        autoNextCourse: true,       // 自动切换下一课程
        autoAdvanceEnabled: true,   // 接口驱动：列表页按 listCourse 接口未完成课程自动进入下一课
        turboMode: false,           // 极速模式：跳过真实播放，直接调用接口完成课程（15-25秒完成，风险较高）
        turboModeDelay: [15000, 25000], // 极速模式随机延迟范围 [min, max] (ms)
        avoidDirectFinish: true, // 防风控：图文完成时不直接请求课程完成接口（v2/_finishSDK），只模拟点击 .btn-next-end 走站点原生 finishWxCourse 链路；false 恢复旧行为（可能触发 701 风控）
        riskPageMode: true,      // 风控页慢速翻页：检测到带 callApinext / antiFraudIdentifyAnalysis / jupitersse 脚本的图文页，
                                 //   每翻一页至少停留 riskPageTurnDelay[0]~[1] ms（站点侧按停留时长判定刷课，翻太快 → 701）
        riskPageTurnDelay: [10000, 15000], // 风控页翻页间隔随机范围 [min, max] (ms)
        canvasAutoBack: false,      // Canvas 微课：完成后自动点击"返回列表"回到课程列表（默认关，避免自动跳转）
        waitForEstTimeout: 5000,    // 等待 est 对象超时(ms)
        minVideoPlayTime: 5000,     // 视频最小播放时间(ms)
        realVideoPlay: false,       // 真实视频播放模式：自动 2x 速度真实播放，等待播放完成后再进入下一步（关闭则保持快速跳过）
        videoPlaybackRate: 2,       // 真实视频播放模式的播放倍速
        courseRepeatLimit: 3,       // 防循环：同一课程连续进入次数达到该值则自动跳回 weiban 首页
        debugMode: false,
        // 日志设置
        logPersist: true,           // 本地持久化日志（刷新保留）
        logMax: 100,                // 日志最大保留条数
        showDebugLogs: true,        // 面板显示 debug 级别日志
        // AI 答题配置（顶层字段，向后兼容旧 ConfigManager）
        enableAIAnswer: true,       // 启用 AI 答题
        aiApiUrl: 'http://api.mk.heymeta.cn',   // 默认 AI 服务地址
        aiApiKey: '',               // API Key 已移除（敏感凭据），请通过 AI 设置面板自行配置
        aiModel: 'qwen-plus',      // AI 模型
        aiTimeout: 30000,           // AI 请求超时(ms)
        aiMaxRetries: 2,            // AI 请求最大重试次数

        // AI 详细配置（面板编辑使用）
        aiConfig: {
            apiUrl: 'http://api.mk.heymeta.cn',
            apiKey: '',
            model: 'qwen-plus',
            timeout: 30000,
            maxRetries: 2,
            temperature: 0.1,
            maxTokens: 50,
            useDefaultPrompt: true,
            systemPrompt: DEFAULT_SYSTEM_PROMPT
        },

        // 云端题库配置
        cloudBank: {
            enabled: true,              // 是否启用云端题库（默认启用，云端预置官方题库+社区题库）
            endpoint: 'http://api.mk.heymeta.cn',  // 云端服务地址
            autoUpload: false,           // AI 答出后是否自动上传到云端
            queryBeforeAI: true,         // 调用 AI 前是否先查询云端
            matchStrategy: 'both',       // 'exact' | 'prefix' | 'both'
            guestReport: true,           // 游客上报学习进度（无需登录云端，管理员统计用户/进度用）
            autoGuestLogin: true          // 自动注册"游客账号"并登录云端（默认开；关闭后退出登录即可切换正式账号）
        },

        // 面板 UI 显示开关
        ui: {
            showProjectPanel: true,
            showCourseList: true,
            showExamPanel: true
        }
    };

    // ========== TDZ 安全日志辅助 ==========
    // const Logger 在脚本中段（约 947 行）才定义；document-start 阶段（ConfigManager.load 等在
    // Logger 初始化前同步执行）若直接调用 Logger 会抛 "Cannot access 'Logger' before initialization"。
    // 此辅助在 Logger 可用前自动退化为 console 输出，彻底消除"Logger 初始化顺序问题"警告。
    function earlyLog(level) {
        const args = Array.prototype.slice.call(arguments, 1);
        try {
            // typeof 对 TDZ 中的 const/let 也会抛 ReferenceError，被外层 try 捕获 → 走 console 兜底
            if (typeof Logger !== 'undefined' && Logger && typeof Logger[level] === 'function') {
                Logger[level].apply(Logger, args);
                return;
            }
        } catch (_) {}
        try {
            const c = (level === 'debug') ? console.debug
                : (level === 'warning') ? console.warn
                : (level === 'success' || level === 'info') ? console.log
                : console.log;
            c.apply(console, args);
        } catch (_) {}
    }

    // ========== GM 存储 JSON 序列化辅助 ==========
    // 不同脚本管理器对 GM_setValue 传对象的行为不一致：
    //   - ScriptCat：JSON 序列化存储，GM_getValue 返回已解析对象
    //   - Tampermonkey：String(value) 强转，对象会变成 "[object Object]"（持久化静默失效）
    //   - Violentmonkey：支持对象直存
    // 这里统一显式 JSON.stringify / JSON.parse，并兼容"管理器已反序列化返回对象"的情况，
    // 保证"持久化面板设置"（显隐 / 位置 / 最小化 / 标签页 / 折叠 / 筛选）跨管理器可靠。
    function gmReadJSON(key, fallback) {
        try {
            const raw = GM_getValue(key, null);
            if (raw === null || raw === undefined) return fallback;
            if (typeof raw === 'string') {
                try {
                    const parsed = JSON.parse(raw);
                    return parsed ?? fallback;
                } catch (_) { return raw; }
            }
            return raw; // 管理器已解析成对象（ScriptCat 等）
        } catch (_) { return fallback; }
    }
    function gmWriteJSON(key, obj) {
        try { GM_setValue(key, JSON.stringify(obj)); return true; }
        catch (_) { return false; }
    }

    // ========== 配置持久化 ==========
    const ConfigManager = {
        STORAGE_KEY: 'shuake_config',

        defaults: { ...CONFIG },

        // 内部 GM 存储包装（带 try-catch + 配额检测）
        _gmGet(key, defaultValue = null) {
            try {
                const v = GM_getValue(key, defaultValue);
                return v === undefined ? defaultValue : v;
            } catch (e) {
                earlyLog('debug', `GM_getValue 失败 (${key}): ${e.message}`);
                return defaultValue;
            }
        },

        _gmSet(key, value) {
            try {
                GM_setValue(key, value);
                return true;
            } catch (e) {
                // 可能是配额超限
                earlyLog('warning', `GM_setValue 失败 (${key}): ${e.message}`);
                return false;
            }
        },

        load() {
            try {
                const saved = gmReadJSON(this.STORAGE_KEY, null);
                if (saved && typeof saved === 'object') {
                    // 合并默认值与已保存值（只保留 defaults 中已定义的 key）
                    const merged = { ...this.defaults };
                    for (const k of Object.keys(saved)) {
                        if (k in merged && saved[k] !== undefined && saved[k] !== null) {
                            merged[k] = saved[k];
                        }
                    }
                    // 【持久化完善】嵌套对象字段级深合并：
                    // 旧存档可能缺少 aiConfig.systemPrompt / cloudBank.matchStrategy 等
                    // 新增字段，若整体覆盖会导致字段丢失（回显 undefined、默认逻辑失效）。
                    // 这里对已知的嵌套配置对象按 defaults 逐字段补齐。
                    const nestedKeys = ['aiConfig', 'cloudBank', 'ui'];
                    for (const nk of nestedKeys) {
                        const defSub = this.defaults[nk];
                        const savedSub = saved[nk];
                        if (defSub && typeof defSub === 'object' && savedSub && typeof savedSub === 'object') {
                            merged[nk] = { ...defSub, ...savedSub };
                        }
                    }
                    Object.assign(CONFIG, merged);
                    // 【云端端点迁移】旧默认值指向 localhost:3000（前端 dev server 端口，常被占用/漂移），
                    // 已保存的配置若仍是该死地址则自动迁移到后端直连 8080，避免登录/同步 "Failed to fetch"。
                    try {
                        const oldEp = (CONFIG.cloudBank && CONFIG.cloudBank.endpoint) || '';
                        const DEAD_EP = /^https?:\/\/localhost:3000\/?$/i;
                        if (DEAD_EP.test(String(oldEp).trim())) {
                            CONFIG.cloudBank = CONFIG.cloudBank || {};
                            CONFIG.cloudBank.endpoint = 'http://api.mk.heymeta.cn';
                            earlyLog('info', '云端服务地址已从 ' + oldEp + ' 自动迁移到 http://api.mk.heymeta.cn');
                            this.save();
                        }
                    } catch (_) {}
                    earlyLog('debug', '配置已加载', CONFIG);
                }
            } catch (e) {
                earlyLog('debug', `配置加载失败: ${e.message}`);
            }
        },

        save() {
            try {
                gmWriteJSON(this.STORAGE_KEY, { ...CONFIG });
                earlyLog('debug', '配置已保存');
            } catch (e) {
                earlyLog('debug', `配置保存失败: ${e.message}`);
            }
        },

        update(key, value) {
            if (key in CONFIG) {
                CONFIG[key] = value;
                this.save();
                return true;
            }
            return false;
        },

        reset() {
            Object.assign(CONFIG, this.defaults);
            this.save();
            earlyLog('info', '配置已重置为默认值');
        }
    };

    // 初始化配置
    ConfigManager.load();

    // ========== 面板 UI 状态持久化 ==========
    // 持久化面板自身的界面状态（拖拽位置 / 最小化 / 显隐 / 标签页 / 折叠区块 / 日志与题库筛选），
    // 与 ConfigManager（保存业务设置）分开存储，避免互相污染。
    const PanelState = {
        STORAGE_KEY: 'shuake_panel_state',

        defaults: {
            pos: null,               // { left, top } 拖拽后的位置
            minimized: false,
            panelVisible: true,
            activeTab: 'main',
            expanded: { course: true, cloud: false, last: false, basic: true, ai: false, logs: true, shortcut: false },
            logSearch: '',
            logLevel: 'all',
            bankFilter: { q: '', type: 'all', source: 'all' }
        },

        load() {
            try {
                const saved = gmReadJSON(this.STORAGE_KEY, null);
                if (saved && typeof saved === 'object') {
                    const merged = { ...this.defaults };
                    for (const k of Object.keys(saved)) {
                        if (k in merged && saved[k] !== undefined && saved[k] !== null) {
                            merged[k] = saved[k];
                        }
                    }
                    // 嵌套对象逐字段合并，避免历史数据缺字段
                    if (saved.expanded && typeof saved.expanded === 'object') {
                        merged.expanded = { ...this.defaults.expanded, ...saved.expanded };
                    }
                    if (saved.bankFilter && typeof saved.bankFilter === 'object') {
                        merged.bankFilter = { ...this.defaults.bankFilter, ...saved.bankFilter };
                    }
                    return merged;
                }
            } catch (e) {
                try { earlyLog('debug', `面板状态加载失败: ${e.message}`); } catch (_) {}
            }
            return { ...this.defaults };
        },

        save(obj) {
            try {
                gmWriteJSON(this.STORAGE_KEY, obj);
                return true;
            } catch (e) {
                try { earlyLog('warning', `面板状态保存失败: ${e.message}`); } catch (_) {}
                return false;
            }
        },

        reset() {
            this.save({ ...this.defaults });
        }
    };

    // ========== 拦截网页 alert ==========
    (function() {
        try {
            // 主窗口拦截
            const originalAlert = window.alert;
            window.alert = function(msg) {
                try { earlyLog('debug', `拦截 alert: ${msg}`); } catch (_) {}
            };

            // iframe alert 拦截
            const wrapIframeAlert = (iframe) => {
                try {
                    const win = iframe?.contentWindow;
                    if (win && win !== window) {
                        win.alert = window.alert;
                    }
                } catch(e) {}
            };

            // 拦截现有和新创建的 iframe
            try { document.querySelectorAll('iframe').forEach(wrapIframeAlert); } catch (_) {}

            try {
                new MutationObserver(() => {
                    try { document.querySelectorAll('iframe').forEach(wrapIframeAlert); } catch (_) {}
                }).observe(document.documentElement, { childList: true, subtree: true });
            } catch (_) {}

            // 定期扫描 iframe（保存 ID 以便清理）
            // 【性能优化】上方 MutationObserver 已实时兜底，此周期扫描仅作为其失效时的后备，
            // 从 2s 降到 10s，避免每 2 秒全量遍历 document 中所有 iframe。
            setInterval(() => {
                try { document.querySelectorAll('iframe').forEach(wrapIframeAlert); } catch (_) {}
            }, 10000);
        } catch (e) {
            try { console.error('alert 拦截初始化失败', e); } catch (_) {}
        }
    })();

    // ========== 日志系统 ==========
    const Logger = {
        LOG_KEY: 'shuake_logs_v1',
        logs: [],
        maxLogs: 100,
        _persistTimer: null,   // localStorage 写入节流定时器（主循环高频日志不再每轮同步写）

        // 从 localStorage 恢复历史日志（刷新保留）
        _restore() {
            try {
                if (!(CONFIG && CONFIG.logPersist !== false)) return;
                const raw = localStorage.getItem(this.LOG_KEY);
                if (!raw) return;
                const arr = SafeJSON.parse(raw, null);
                if (!Array.isArray(arr)) return;
                this.logs = arr
                    .filter((e) => e && typeof e === 'object' && e.message != null)
                    .slice(0, this.maxLogs);
            } catch (_) {}
        },

        // 持久化日志到 localStorage（控容，失败减半重试）
        // 【性能优化】主循环每 1.2s 产生多条日志；若每次 add 都同步写 localStorage，
        // 会造成频繁 JSON.stringify + setItem 阻塞主线程。这里改为节流：500ms 内合并为一次写。
        _persist() {
            try {
                if (!(CONFIG && CONFIG.logPersist !== false)) return;
                if (this._persistTimer) return; // 已有待写入的定时器，合并
                this._persistTimer = setTimeout(() => {
                    this._persistTimer = null;
                    this._flushPersist();
                }, 500);
            } catch (_) {}
        },

        // 实际执行 localStorage 写入
        _flushPersist() {
            try {
                if (!(CONFIG && CONFIG.logPersist !== false)) return;
                const maxLogs = (CONFIG && CONFIG.logMax) || this.maxLogs || 100;
                const slim = this.logs.slice(0, maxLogs).map((e) => ({
                    time: e.time,
                    ts: e.ts,
                    level: e.level,
                    message: e.message,
                    data: e.data,
                    count: e.count || 1
                }));
                try {
                    localStorage.setItem(this.LOG_KEY, JSON.stringify(slim));
                } catch (_) {
                    try {
                        localStorage.setItem(this.LOG_KEY, JSON.stringify(slim.slice(0, Math.ceil(slim.length / 2))));
                    } catch (_) {}
                }
            } catch (_) {}
        },

        // 清除持久化日志
        _clearPersist() {
            try { if (this._persistTimer) { clearTimeout(this._persistTimer); this._persistTimer = null; } } catch (_) {}
            try { localStorage.removeItem(this.LOG_KEY); } catch (_) {}
        },

        // 安全格式化日志数据（防止循环引用 / DOM 节点 / 异常对象）
        _safeStringify(data) {
            if (data == null) return '';
            if (typeof data === 'string') return data;
            if (typeof data === 'number' || typeof data === 'boolean') return String(data);
            if (data instanceof Error) return `${data.name}: ${data.message}`;
            if (data instanceof Element) return `<${data.tagName.toLowerCase()}${data.id ? '#'+data.id : ''}${data.className ? '.'+String(data.className).trim().split(/\s+/).join('.') : ''}>`;
            try {
                const seen = new WeakSet();
                return JSON.stringify(data, (key, val) => {
                    if (typeof val === 'object' && val !== null) {
                        if (val instanceof Element) return `<${val.tagName.toLowerCase()}>`;
                        if (seen.has(val)) return '[Circular]';
                        seen.add(val);
                    }
                    if (typeof val === 'function') return `[Function: ${val.name || 'anonymous'}]`;
                    if (typeof val === 'undefined') return '[undefined]';
                    return val;
                });
            } catch (e) {
                return '[Unstringifiable]';
            }
        },

        add(level, message, data = null) {
            try {
                // 防止 message 是非字符串
                const safeMessage = (message == null) ? '' :
                    (typeof message === 'string') ? message :
                    (message instanceof Error) ? `${message.name}: ${message.message}` :
                    this._safeStringify(message);

                const safeData = (data == null) ? null : this._safeStringify(data);
                const maxLogs = (CONFIG && CONFIG.logMax) || this.maxLogs || 100;
                const now = Date.now();

                // 连续重复折叠：同级别 + 同消息 → 计数 +1（降低轮询噪音）
                const top = this.logs[0];
                if (top && top.level === level && top.message === safeMessage) {
                    top.count = (top.count || 1) + 1;
                    top.ts = now;
                    top.time = new Date(now).toLocaleTimeString();
                    this._persist();
                } else {
                    const entry = {
                        time: new Date(now).toLocaleTimeString(),
                        ts: now,
                        level,
                        message: safeMessage,
                        data: safeData,
                        count: 1
                    };
                    this.logs.unshift(entry);
                    if (this.logs.length > maxLogs) {
                        this.logs.pop();
                    }
                    this._persist();
                }

                const prefix = {
                    info: 'ℹ️',
                    success: '✅',
                    warning: '⚠️',
                    error: '❌',
                    debug: '🔍'
                }[level] || '📌';

                const logMessage = `[${new Date(now).toLocaleTimeString()}] ${prefix} ${safeMessage}`;
                if (CONFIG.debugMode || level !== 'debug') {
                    console.log(logMessage, data || '');
                }
            } catch (e) {
                // 兜底：Logger 自身出错也不能让脚本崩
                try { console.error('[Logger] error:', e); } catch (_) {}
            }
        },

        info(msg, data) { this.add('info', msg, data); },
        success(msg, data) { this.add('success', msg, data); },
        warning(msg, data) { this.add('warning', msg, data); },
        warn(msg, data) { this.add('warning', msg, data); },
        error(msg, data) { this.add('error', msg, data); },
        debug(msg, data) { this.add('debug', msg, data); }
    };

    // 启动时恢复持久化历史日志（刷新保留）
    try { Logger._restore(); } catch (_) {}

    // 云端账户登录态恢复已移至 CloudAuth 定义之后调用（此处 CloudAuth 尚未定义，const TDZ 会导致 typeof 抛错被吞）

    // ========== 网络请求工具 ==========
    const Network = {
        // 创建带超时的 fetch，超时使用 AbortController
        _fetchWithTimeout(url, options = {}, timeout = 30000) {
            const controller = new AbortController();
            const timer = setTimeout(() => {
                try { controller.abort(); } catch (_) {}
            }, timeout);
            // 如果 options 已有 signal，链接（不覆盖原 signal）
            const mergedOptions = { ...options, signal: options.signal || controller.signal };
            return fetch(url, mergedOptions)
                .finally(() => {
                    clearTimeout(timer);
                });
        },

        async fetchWithRetry(url, options = {}, retries = 3, delay = 1000) {
            const {
                retryCondition = (res) => !res.ok,
                timeout = 30000,
                ...fetchOptions
            } = options;

            for (let i = 0; i <= retries; i++) {
                try {
                    const resp = await this._fetchWithTimeout(url, {
                        credentials: 'include',
                        ...fetchOptions
                    }, timeout);

                    if (!retryCondition(resp)) {
                        // 尝试解析 JSON，失败则返回 Response 对象
                        try {
                            return await resp.json();
                        } catch (_) {
                            return resp;
                        }
                    }

                    if (i < retries) {
                        await this.sleep(delay * (i + 1));
                    }
                } catch (e) {
                    // 区分超时错误与其他错误
                    const isAbort = e?.name === 'AbortError';
                    if (i === retries) {
                        try { Logger.debug(`fetchWithRetry 最终失败: ${e?.message || e}`); } catch (_) {}
                        if (isAbort) return null; // 超时不再重试上层
                        throw e;
                    }
                    try { Logger.debug(`fetchWithRetry 第${i+1}次失败: ${e?.message || e}`); } catch (_) {}
                    await this.sleep(delay * (i + 1));
                }
            }
            return null;
        },

        sleep(ms) {
            if (!ms || ms < 0) return Promise.resolve();
            return new Promise(resolve => setTimeout(resolve, ms));
        }
    };

    // ========== XHR/fetch 劫持封装（基于 ajax-hook） ==========
    // 自动捕获 token、x-token、课程进度上报、inject 调用等关键请求
    const AjaxHooker = {
        _hooked: false,
        _unhook: null,
        // 监听 URL 模式：匹配则触发回调（接收 config + response body）
        _listeners: new Map(), // pattern -> callback
        // 最近捕获的 token（按 header 名）
        _tokens: new Map(), // headerName -> token
        // 站点自身请求的完整 headers 快照（供复刻请求模拟，用户建议：拦截其他请求的头来模拟）
        _siteHeaders: {},

        // 返回站点自身请求的 headers 快照副本（过滤 fetch 禁用的 forbidden headers）
        getSiteHeaders() {
            const forbidden = ['cookie', 'origin', 'referer', 'host', 'content-length', 'user-agent', 'accept-encoding', 'connection', 'keep-alive', 'transfer-encoding', 'upgrade', 'sec-fetch-site', 'sec-fetch-mode', 'sec-fetch-dest'];
            try {
                const out = {};
                for (const k of Object.keys(this._siteHeaders)) {
                    const lk = String(k).toLowerCase();
                    if (forbidden.includes(lk)) continue;
                    const v = this._siteHeaders[k];
                    if (v != null && String(v).length > 0 && String(v).length < 2048) out[k] = v;
                }
                return out;
            } catch (_) { return {}; }
        },

        /**
         * 启动劫持；幂等
         */
        install() {
            if (this._hooked) return true;
            if (!Libs.hasAjaxHook) {
                try { Logger.warning('ajax-hook 未加载，跳过劫持'); } catch (_) {}
                return false;
            }
            try {
                const hooks = {
                    onRequest: (config, async) => {
                        try {
                            // 1) 捕获请求头中的 token
                            this._captureTokensFromHeaders(config.headers);
                            // 1.5) 从站点请求 URL/body 截取身份参数并持久化
                            this._captureIdentityFromRequest(config.url, config.body);
                            // 2) 触发监听器（请求阶段）
                            for (const [pattern, cb] of this._listeners) {
                                if (this._matchUrl(config.url, pattern)) {
                                    try { cb('request', config, null); } catch (_) {}
                                }
                            }
                        } catch (e) {
                            try { Logger.debug(`onRequest 异常: ${e.message}`); } catch (_) {}
                        }
                    },
                    onResponse: (response, async) => {
                        try {
                            // 0) 风控检测：XHR 响应 701 = 账号被风控，上报 + 自动暂停
                            try {
                                const _st = (response && response.status) || (response && response.config && response.config.status) || 0;
                                if (_st === 701) RiskControl.handle701(701, (response && response.config && response.config.url) || '');
                            } catch (_) {}
                            // 1) 触发监听器（响应阶段）
                            for (const [pattern, cb] of this._listeners) {
                                if (this._matchUrl(response.config?.url || '', pattern)) {
                                    let body = response.response;
                                    if (typeof body === 'string') {
                                        try { body = SafeJSON.parse(body, body); } catch (_) {}
                                    }
                                    try { cb('response', response.config, body); } catch (_) {}
                                }
                            }
                        } catch (e) {
                            try { Logger.debug(`onResponse 异常: ${e.message}`); } catch (_) {}
                        }
                    },
                    onError: (err, async) => {
                        try { Logger.debug(`XHR 错误: ${err?.error?.message || 'unknown'}`); } catch (_) {}
                    }
                };
                const proxy = Libs.ah.proxy(hooks);
                this._unhook = proxy.unProxy;
                this._hooked = true;
                Logger.info('ajax-hook 已安装');
                return true;
            } catch (e) {
                try { Logger.error(`ajax-hook 安装失败: ${e.message}`); } catch (_) {}
                return false;
            }
        },

        /**
         * 取消劫持
         */
        uninstall() {
            try { if (this._unhook) this._unhook(); } catch (_) {}
            this._hooked = false;
            this._unhook = null;
        },

        /**
         * 注册 URL 模式监听
         * @param {string|RegExp} pattern 字符串子串匹配或正则
         * @param {(phase:'request'|'response', config, body) => void} callback
         * @returns {Function} 取消注册
         */
        on(pattern, callback) {
            if (!pattern || typeof callback !== 'function') return () => {};
            this._listeners.set(pattern, callback);
            return () => this._listeners.delete(pattern);
        },

        /**
         * 等待某个 URL 模式的请求出现并返回其响应体
         * @param {string|RegExp} pattern
         * @param {number} [timeout=10000] ms
         * @returns {Promise<{config, body}>}
         */
        waitFor(pattern, timeout = 10000) {
            return new Promise((resolve, reject) => {
                let timer = null;
                const off = this.on(pattern, (phase, config, body) => {
                    if (phase === 'response') {
                        if (timer) clearTimeout(timer);
                        off();
                        resolve({ config, body });
                    }
                });
                if (timeout > 0) {
                    timer = setTimeout(() => {
                        off();
                        reject(new Error('waitFor 超时'));
                    }, timeout);
                }
            });
        },

        /**
         * 从 Headers 中提取 token
         */
        _captureTokensFromHeaders(headers) {
            if (!headers) return;
            const tokenNames = ['x-token', 'token', 'authorization', 'auth-token', 'access_token'];
            try {
                // Headers 可能是 Headers 对象或普通对象
                const entries = [];
                if (typeof headers.entries === 'function') {
                    for (const [k, v] of headers.entries()) entries.push([k, v]);
                } else if (typeof headers === 'object') {
                    for (const k of Object.keys(headers)) entries.push([k, headers[k]]);
                }
                for (const [k, v] of entries) {
                    const lk = String(k).toLowerCase();
                    if (tokenNames.includes(lk) && v) {
                        this._tokens.set(lk, v);
                    }
                    // 同步缓存到站点 headers 快照（供复刻请求模拟）
                    if (v != null) this._siteHeaders[String(k)] = v;
                }
            } catch (e) {}
        },

        /**
         * 从站点 API 请求 URL/body 中截取身份参数（userProjectId/userId/tenantCode 等）并持久化
         * 来源：站点自身请求（listCourse.do body=userProjectId&tenantCode；listPrePlan.do body=tenantCode&userId&userProjectId）
         */
        _captureIdentityFromRequest(url, body) {
            try {
                let text = '';
                if (typeof body === 'string') text = body;
                else if (body && typeof body === 'object') {
                    try { text = new URLSearchParams(body).toString(); } catch (_) { text = ''; }
                }
                const q = {};
                try {
                    const u = new URL(String(url || ''), window.location.href);
                    u.searchParams.forEach((v, k) => { if (v) q[k] = v; });
                } catch (_) {}
                try {
                    if (text) new URLSearchParams(text).forEach((v, k) => { if (v && !q[k]) q[k] = v; });
                } catch (_) {}
                const want = ['userProjectId', 'userId', 'tenantCode', 'courseId', 'userCourseId'];
                let dirty = false;
                const cur = StoredIdentity.load() || {};
                for (const k of want) {
                    if (q[k] && !cur[k]) { cur[k] = q[k]; dirty = true; }
                }
                if (dirty) {
                    try { localStorage.setItem(StoredIdentity.KEY, JSON.stringify(cur)); } catch (_) {}
                }
            } catch (_) {}
        },

        /**
         * 获取已捕获的 token
         * @param {string} [name='x-token'] header 名（不区分大小写）
         * @returns {string|null}
         */
        getToken(name = 'x-token') {
            for (const [k, v] of this._tokens) {
                if (k.toLowerCase() === name.toLowerCase()) return v;
            }
            return null;
        },

        /**
         * 简单 URL 匹配
         */
        _matchUrl(url, pattern) {
            if (!url) return false;
            if (pattern instanceof RegExp) return pattern.test(url);
            return String(url).includes(pattern);
        },

        /**
         * 劫持 window.fetch：站点若用 fetch（而非 XHR）调 pharos API，同样触发监听器。
         * 幂等；失败静默（不阻塞页面）。
         */
        installFetch() {
            try {
                if (this._fetchHooked) return true;
                if (typeof window === 'undefined' || typeof window.fetch !== 'function') return false;
                const originalFetch = window.fetch.bind(window);
                const self = this;
                this._originalFetch = originalFetch;
                // 响应窃听（供 window.fetch 包装与 apiFetch 共用）
                const handleResponse = (p, url) => {
                    p.then((resp) => {
                        try {
                            const rurl = (resp && resp.url) ? resp.url : url;
                            // 【风控检测】HTTP 701 = 账号被风控（access-denial），无论是否命中监听都触发
                            try { if (resp && resp.status === 701) RiskControl.handle701(resp.status, rurl); } catch (_) {}
                            let hit = false;
                            for (const [pattern, cb] of self._listeners) {
                                if (self._matchUrl(rurl, pattern)) { hit = true; break; }
                            }
                            if (!hit) return;
                            const clone = resp && typeof resp.clone === 'function' ? resp.clone() : null;
                            if (!clone || typeof clone.text !== 'function') return;
                            clone.text().then((text) => {
                                try {
                                    let body = text;
                                    if (typeof body === 'string') body = SafeJSON.parse(body, body);
                                    for (const [pattern, cb] of self._listeners) {
                                        if (self._matchUrl(rurl, pattern)) {
                                            try { cb('response', { url: rurl }, body); } catch (_) {}
                                        }
                                    }
                                } catch (_) {}
                            }).catch(() => {});
                        } catch (_) {}
                    }).catch(() => {});
                };
                window.fetch = function (input, init) {
                    let url = '';
                    try {
                        url = typeof input === 'string' ? input : (input && input.url) ? input.url : String(input || '');
                    } catch (_) {}
                    // 请求阶段：捕获站点 fetch 的真实 token/身份（内部请求走 apiFetch 不经此处，不会自我污染）
                    try {
                        const headers = (init && init.headers) || (input && input.headers);
                        self._captureTokensFromHeaders(headers);
                        self._captureIdentityFromRequest(url, (init && init.body) || '');
                        for (const [pattern, cb] of self._listeners) {
                            if (self._matchUrl(url, pattern)) {
                                try { cb('request', { url, headers }, null); } catch (_) {}
                            }
                        }
                    } catch (_) {}
                    const p = originalFetch(input, init);
                    handleResponse(p, url);
                    return p;
                };
                this._handleResponse = handleResponse;
                this._fetchHooked = true;
                return true;
            } catch (_) { return false; }
        },

        // 脚本自身请求专用：直接走原始 fetch，绕过 window.fetch 包装，
        // 避免把我们的请求头写进站点 token 快照；仍做响应窃听。
        apiFetch(input, init) {
            const originalFetch = this._originalFetch || (typeof window !== 'undefined' ? window.fetch.bind(window) : null);
            if (!originalFetch) {
                return typeof window !== 'undefined' ? window.fetch(input, init) : Promise.reject(new Error('no fetch'));
            }
            let url = '';
            try { url = typeof input === 'string' ? input : (input && input.url) ? input.url : String(input || ''); } catch (_) {}
            const p = originalFetch(input, init);
            try {
                if (this._handleResponse) this._handleResponse(p, url);
                else {
                    p.then((resp) => {
                        try {
                            const rurl = (resp && resp.url) ? resp.url : url;
                            for (const [pattern, cb] of this._listeners) {
                                if (this._matchUrl(rurl, pattern)) {
                                    try { cb('response', { url: rurl }, null); } catch (_) {}
                                }
                            }
                        } catch (_) {}
                    }).catch(() => {});
                }
            } catch (_) {}
            return p;
        }
    };

    // ========== 状态管理 ==========
    const State = {
        isRunning: false,   // 默认不自动刷课：面板点击"开始刷课"才启动（用户要求）
        isPaused: false,
        isVideoPage: false,
        videoCompleted: false,
        graphicCompleted: false,
        currentCourseName: '',
        retryCount: 0,
        stuckCount: 0,
        startTime: null,
        // ---- 刷课状态上报（云端，前提：登录云端账号） ----
        studyStartedAt: null,   // 本课刷课开始时间戳（首次翻页时惰性初始化）
        studyPageTurns: 0,      // 本课翻页计数（每次翻页 +1）
        studyReported: false,   // 本课是否已上报完成/失败（防重，每课 POST 一次）
        studyReportId: null,    // 最近一次上报返回的记录 ID
        studyStatus: 'running', // 本课当前状态（running/completed/failed）
        studyHeartbeatTimer: null, // 心跳定时器（对齐刷课统计 API v1.2：每 60s 一次）
        studyCourseName: '',    // 本课课程名快照
        isCaptchaPage: false,
        estReady: false,
        hasClickedStart: false,
        lastTriggerClickTime: null,   // 上一次逐一点击触发器的时间(ms)，用于 3s 冷却
        boxWaitCount: 0,              // 等待 boxbg 显示的累计轮数（每点中触发器或换页时重置）
        lastReclickKey: null,         // 最近一次 reclick 的目标标识（用于 reclick 上限计数）
        reclickCount: 0,              // 同一 content 连续 reclick 次数（>3 转等待）
        lastForceAdvanceIdx: null,    // 最近一次强制翻页的目标 section 索引（用于回退检测）
        lastForceAdvanceTime: null,   // 最近一次强制翻页的时间
        forceAdvanceReverts: 0,       // 强制翻页被站点回退的累计次数（≥2 停用强制翻页）
        lastCourseId: null,           // 接口驱动：最近一次自动进入的课程 ID（用于跳转到下一未完成课）
        pendingCourses: [],           // 接口驱动：未完成课程队列（接口数据）
        allCourses: [],               // 接口驱动：全部课程（接口数据）
        _startBtnWatched: false, // DOMWatcher 是否已订阅开始按钮；'clicked' = 已触发点击，true = 正在等待
        _autoPausedOnComplete: false, // 已完成自动暂停标记：所有课程完成后已自动暂停一次，防止重复触发
        lastNextClickTime: null,   // 上一次点击 .btn-next 的时间(ms)，用于对齐站点 btn_timer=1200ms 节流，避免点击被吞
        _v2CompleteCalled: false,  // 本课程页是否已调用过 v2 完成接口（每页一次，防重复）
        startBtnClickTime: null,    // 开始按钮点击时间
        startBtnRetryCount: 0,      // 开始按钮点击重试次数
        startBtnClickedSectionIdx: null, // 点击开始按钮时所在的 section 索引（用于判断是否真正翻页）
        isPageTurning: false,    // 翻页中状态（点击按钮已派发，等待页面真正切换）
        lastActivePage: null,    // 上一次活跃页（用于识别页面真正变化的 URL/页面 ID）
        lastActiveSectionId: null, // 上一次活跃 page-item 的标识（用于检测翻页后的真实切换）
        lastActiveSectionIdx: null, // 上一次活跃 page-item 的索引（排除 page-start/page-end，用于检测 section 切换）
        lastActiveRawPageIdx: null, // 上一次活跃 page-item 的原始索引（包含 page-start / page-end，用于判断"是否刚从起始页进入"）
        pageTurnTriggerTime: null,  // 翻页触发时间戳（用于超时强制解锁）
        pageTurnTriggerSelector: null, // 触发翻页的按钮描述（用于日志）
        quizCompleted: false,    // 问答选择完成状态
        quizAttempts: 0,         // 问答尝试次数
        quizErrorRetry: false,  // 问答错误重试状态
        quizPrevPageIndex: null, // 问答错误前的页码
        maxQuizAttempts: 10,     // 最大尝试次数
        videoPlayStartTime: null, // 视频开始播放时间
        injectExecuted: false,    // inject是否已执行
        endPageJumpTime: null,    // 结束页停留计时
        endPageReturned: false,   // 是否已从列表页返回
        // AI 答题状态
        isExamPage: false,       // 是否在考试页面
        aiAnswerCache: new Map(), // AI 答案缓存（键：题目hash，值：答案索引）
        aiCurrentQuestion: null,  // 当前正在处理的题目
        aiProcessing: false,       // 是否正在处理答题（防止重复）
        aiAnswerSuccess: 0,       // AI答题成功次数
        aiAnswerFailed: 0,        // AI答题失败次数

        reset() {
            this.videoCompleted = false;
            this.graphicCompleted = false;
            this.retryCount = 0;
            this.stuckCount = 0;
            this.isCaptchaPage = false;
            this.quizCompleted = false;
            this.quizAttempts = 0;
            this.quizErrorRetry = false;
            this.quizPrevPageIndex = null;
        },

        resetForNewCourse() {
            this.videoCompleted = false;
            this.graphicCompleted = false;
            this.retryCount = 0;
            this.stuckCount = 0;
            this.hasClickedStart = false;
            this.startBtnClickTime = null;
            this.startBtnRetryCount = 0;
            this.startBtnClickedSectionIdx = null;
            this.isPageTurning = false;
            this.lastActivePage = null;
            this.lastActiveSectionId = null;
            this.lastActiveSectionIdx = null;
            this.lastActiveRawPageIdx = null;
            this.pageTurnTriggerTime = null;
            this.pageTurnTriggerSelector = null;
            this.quizCompleted = false;
            this.quizAttempts = 0;
            this.quizErrorRetry = false;
            this.quizPrevPageIndex = null;
            this.videoPlayStartTime = null;
            this.injectExecuted = false;
            this.endPageJumpTime = null;
            this.endPageReturned = false;
            // 刷课上报：每课重新计时（未登录云端时 ensureStarted 不会启动）
            this.studyStartedAt = null;
            this.studyPageTurns = 0;
            this.studyReported = false;
            this.studyReportId = null;
            this.studyStatus = 'running';
            this.studyCourseName = '';
        }
    };

    // ========== 已完成课程记录（跨页防重复刷） ==========
    // 站点 listCourse.do 的 finished 标记可能存在更新延迟：课程实际刷完后，
    // 短时间内接口仍返回未完成，导致 autoAdvanceByAPI 反复进入同一门已刷完的课。
    // 本工具用 localStorage 按"天"记录已完成课程 ID，供列表页自动选课过滤。
    // 跨天自动失效，不影响用户次日手动重刷。
    const CompletedCourses = {
        KEY: 'shuake_completed_courses_v1',
        _dayKey() {
            const d = new Date();
            return `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;
        },
        load() {
            try {
                const raw = localStorage.getItem(this.KEY);
                const obj = raw ? JSON.parse(raw) : null;
                if (obj && obj.day === this._dayKey() && Array.isArray(obj.ids)) {
                    return new Set(obj.ids);
                }
            } catch (_) {}
            return new Set();
        },
        _save(set) {
            try {
                localStorage.setItem(this.KEY, JSON.stringify({ day: this._dayKey(), ids: Array.from(set) }));
            } catch (_) {}
        },
        add(id) {
            if (!id) return;
            const set = this.load();
            set.add(String(id));
            this._save(set);
        },
        has(id) {
            return id ? this.load().has(String(id)) : false;
        }
    };

    // ========== 统计信息 ==========
    const Statistics = {
        startTime: null,
        coursesCompleted: 0,
        coursesTotal: 0,
        totalPagesViewed: 0,
        totalErrors: 0,
        lastErrorTime: null,
        _saveTimer: null,

        init() {
            this.startTime = Date.now();
            this.load();
        },

        load() {
            try {
                const saved = gmReadJSON('shuake_stats', {});
                if (saved && typeof saved === 'object') {
                    if (typeof saved.coursesCompleted === 'number' && saved.coursesCompleted >= 0) {
                        this.coursesCompleted = saved.coursesCompleted;
                    }
                    if (typeof saved.totalPagesViewed === 'number' && saved.totalPagesViewed >= 0) {
                        this.totalPagesViewed = saved.totalPagesViewed;
                    }
                    if (typeof saved.totalErrors === 'number' && saved.totalErrors >= 0) {
                        this.totalErrors = saved.totalErrors;
                    }
                }
            } catch(e) {
                try { Logger.debug(`统计加载失败: ${e.message}`); } catch (_) {}
            }
        },

        // 节流保存，避免频繁写入
        save() {
            if (this._saveTimer) return;
            this._saveTimer = setTimeout(() => {
                this._saveTimer = null;
                try {
                    gmWriteJSON('shuake_stats', {
                        coursesCompleted: this.coursesCompleted,
                        totalPagesViewed: this.totalPagesViewed,
                        totalErrors: this.totalErrors
                    });
                } catch(e) {
                    try { Logger.debug(`统计保存失败: ${e.message}`); } catch (_) {}
                }
            }, 2000);
        },

        recordCourseComplete() {
            this.coursesCompleted++;
            this.save();
        },

        recordPageView() {
            this.totalPagesViewed++;
            this.save();
            // 【刷课上报】统一翻页计数点：四 Tier 翻页 + 视频完成都经此
            try {
                if (typeof StudyReporter !== 'undefined') {
                    StudyReporter.ensureStarted();
                    StudyReporter.countPageTurn();
                }
            } catch (_) {}
        },

        recordError() {
            this.totalErrors++;
            this.lastErrorTime = new Date();
            this.save();
        },

        // 重置统计（清零 + 持久化）
        reset() {
            this.coursesCompleted = 0;
            this.totalPagesViewed = 0;
            this.totalErrors = 0;
            this.lastErrorTime = null;
            try {
                gmWriteJSON('shuake_stats', {
                    coursesCompleted: 0,
                    totalPagesViewed: 0,
                    totalErrors: 0
                });
            } catch (_) {}
        },

        getDuration() {
            if (!this.startTime) return '0:00';
            const secs = Math.max(0, Math.floor((Date.now() - this.startTime) / 1000));
            const h = Math.floor(secs / 3600);
            const m = Math.floor((secs % 3600) / 60);
            const s = secs % 60;
            return h > 0 ? `${h}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}` : `${m}:${s.toString().padStart(2, '0')}`;
        },

        getSummary() {
            return {
                duration: this.getDuration(),
                coursesCompleted: this.coursesCompleted,
                pagesViewed: this.totalPagesViewed,
                errors: this.totalErrors,
                lastErrorTime: this.lastErrorTime
            };
        }
    };

    // ========== 题库管理（本地规范化存储 + 与云端兼容） ==========
    const QuestionBank = {
        STORAGE_KEY: 'shuake_question_bank_v1',
        LEGACY_KEY: 'shuake_exam_answers',
        STATS_KEY: 'shuake_bank_stats_v1',
        ANSWER_STATS_KEY: 'shuake_answer_stats_v1',
        // 运行时缓存（数组形式）
        _records: [],
        _loaded: false,
        // 命中统计（持久化到 STATS_KEY，刷新不丢）
        stats: {
            localHits: 0,
            cloudHits: 0,
            aiHits: 0
        },
        // 答题结果统计（成功/失败/命中率，持久化到 ANSWER_STATS_KEY）
        answerStats: {
            success: 0,
            failed: 0
        },

        // 持久化命中统计
        _persistStats() {
            try { localStorage.setItem(this.STATS_KEY, JSON.stringify(this.stats)); } catch (_) {}
        },

        // 恢复命中统计
        _restoreStats() {
            try {
                const raw = localStorage.getItem(this.STATS_KEY);
                if (!raw) return;
                const p = SafeJSON.parse(raw, null);
                if (p && typeof p === 'object') {
                    this.stats = Object.assign({ localHits: 0, cloudHits: 0, aiHits: 0 }, p);
                }
            } catch (_) {}
        },

        // 重置命中统计
        resetStats() {
            this.stats = { localHits: 0, cloudHits: 0, aiHits: 0 };
            try { localStorage.removeItem(this.STATS_KEY); } catch (_) {}
            return this.stats;
        },

        // 恢复答题结果统计
        _restoreAnswerStats() {
            try {
                const raw = localStorage.getItem(this.ANSWER_STATS_KEY);
                if (!raw) return;
                const p = SafeJSON.parse(raw, null);
                if (p && typeof p === 'object') {
                    this.answerStats = Object.assign({ success: 0, failed: 0 }, p);
                }
            } catch (_) {}
        },

        // 记录一次答题结果（ok=true 成功 / false 失败），持久化
        recordAnswer(ok) {
            if (ok) this.answerStats.success = (this.answerStats.success || 0) + 1;
            else this.answerStats.failed = (this.answerStats.failed || 0) + 1;
            try { localStorage.setItem(this.ANSWER_STATS_KEY, JSON.stringify(this.answerStats)); } catch (_) {}
            return this.answerStats;
        },

        // 重置答题结果统计
        resetAnswerStats() {
            this.answerStats = { success: 0, failed: 0 };
            try { localStorage.removeItem(this.ANSWER_STATS_KEY); } catch (_) {}
            return this.answerStats;
        },

        // 切换某题的"已验证"标记（答对后手动标记，标记过的题命中权重更高）
        toggleVerified(qHash) {
            if (!qHash) return false;
            this.loadAll();
            let changed = false;
            for (const r of this._records) {
                if (r.qHash === qHash) {
                    r.verified = !r.verified;
                    r.updatedAt = new Date().toISOString();
                    changed = true;
                }
            }
            if (changed) this._writeAll(this._records);
            return changed;
        },

        // 生成稳定的 hash（与 AIAnswer.generateQuestionHash 兼容）
        computeHash(question, options) {
            if (!question) return '0';
            const optStr = Array.isArray(options) ? options.map((o) => (o && (o.content !== undefined ? o.content : o)) || '').join('|') : '';
            const str = String(question) + '|' + optStr;
            let hash = 0;
            for (let i = 0; i < str.length; i++) {
                const char = str.charCodeAt(i);
                hash = ((hash << 5) - hash) + char;
                hash = hash & hash;
            }
            return hash.toString(36);
        },

        _safeReadArray(key) {
            try {
                const raw = localStorage.getItem(key);
                if (!raw) return [];
                const parsed = SafeJSON.parse(raw, []);
                return Array.isArray(parsed) ? parsed : [];
            } catch (_) {
                return [];
            }
        },

        _writeAll(records) {
            try {
                localStorage.setItem(this.STORAGE_KEY, JSON.stringify(records));
            } catch (e) {
                // 容量超限：保留最近的 80%
                if (records.length > 50) {
                    const trimmed = records.slice(Math.floor(records.length * 0.2));
                    try {
                        localStorage.setItem(this.STORAGE_KEY, JSON.stringify(trimmed));
                        Logger.warning(`题库容量超限，已清理为 ${trimmed.length} 条`);
                    } catch (_) {}
                }
            }
        },

        // 从旧 localStorage 迁移
        _migrateLegacy() {
            const legacy = this._safeReadArray(this.LEGACY_KEY);
            if (legacy.length === 0) return [];
            const migrated = legacy.map((old) => this.normalize({
                question: old.question,
                options: old.options,
                answer: old.answer,
                source: 'local',
                createdAt: old.timestamp || new Date().toISOString()
            })).filter(Boolean);
            // 写入新 key 并保留旧 key（便于回退）
            if (migrated.length > 0) {
                try {
                    const existing = this._safeReadArray(this.STORAGE_KEY);
                    const merged = this._mergeRecords(existing, migrated);
                    this._writeAll(merged);
                    Logger.info(`从旧版迁移 ${migrated.length} 条答案到新题库（共 ${merged.length} 条）`);
                } catch (_) {}
            }
            return migrated;
        },

        loadAll() {
            if (this._loaded) return this._records.slice();
            this._loaded = true;
            this._restoreStats();
            this._restoreAnswerStats();
            let records = this._safeReadArray(this.STORAGE_KEY);
            if (records.length === 0) {
                records = this._migrateLegacy();
            } else {
                // 后台尝试迁移旧 key（合并去重）
                setTimeout(() => {
                    try {
                        const legacy = this._migrateLegacy();
                        if (legacy.length > 0) {
                            this._records = this._safeReadArray(this.STORAGE_KEY);
                            try { Logger.info(`题库加载完成，共 ${this._records.length} 条（含迁移）`); } catch (_) {}
                        }
                    } catch (_) {}
                }, 1000);
            }
            // 校验结构：剔除非法记录
            this._records = records.filter((r) => r && typeof r === 'object' && r.qHash && r.question);
            return this._records.slice();
        },

        // 题库为空时，尝试从兄弟子域拉取（跨 origin 桥：列表页与课程页 host 不同时 localStorage 不互通）
        tryCrossOriginLoad() {
            if (this._records && this._records.length > 0) return Promise.resolve(false);
            return DataBridge.requestBank(5000).then((records) => {
                if (!records || records.length === 0) return false;
                const norm = records.map((r) => this.normalize(r)).filter(Boolean);
                if (norm.length === 0) return false;
                const existing = this._safeReadArray(this.STORAGE_KEY);
                const merged = this._mergeRecords(existing, norm);
                this._writeAll(merged);
                this._records = this._safeReadArray(this.STORAGE_KEY);
                try { Logger.info(`跨子域题库桥: 从其他子域拉取 ${norm.length} 条题库（共 ${this._records.length} 条）`); } catch (_) {}
                return true;
            }).catch(() => false);
        },

        // 将任意输入规范化为标准记录
        normalize(input) {
            if (!input || typeof input !== 'object') return null;
            const question = String(input.question || '').trim();
            if (!question) return null;
            const opts = Array.isArray(input.options) ? input.options : [];
            const normOpts = opts.slice(0, 20).map((o, i) => {
                if (typeof o === 'string') {
                    return { order: String.fromCharCode(65 + i), content: o };
                }
                return {
                    order: String(o.order || String.fromCharCode(65 + i)).slice(0, 8),
                    content: String(o.content || '').slice(0, 1000)
                };
            }).filter((o) => o.content);
            const hash = input.qHash || this.computeHash(question, normOpts);
            const type = ['single', 'multi', 'judge'].includes(input.type) ? input.type : (normOpts.length === 0 ? 'judge' : 'single');
            const now = new Date().toISOString();
            return {
                qHash: hash,
                question: question.slice(0, 2000),
                options: normOpts,
                answer: String(input.answer || '').trim().toUpperCase().slice(0, 64),
                type,
                source: ['local', 'ai', 'manual', 'official'].includes(input.source) ? input.source : 'local',
                verified: !!input.verified,
                createdAt: input.createdAt || now,
                updatedAt: now
            };
        },

        _mergeRecords(a, b) {
            const map = new Map();
            for (const r of a) if (r && r.qHash) map.set(r.qHash, r);
            for (const r of b) {
                if (!r || !r.qHash) continue;
                const exist = map.get(r.qHash);
                if (!exist) {
                    map.set(r.qHash, r);
                } else {
                    if (!exist.answer && r.answer) exist.answer = r.answer;
                    if (r.verified) exist.verified = true;
                    if (!exist.options || exist.options.length === 0) exist.options = r.options;
                }
            }
            return Array.from(map.values());
        },

        upsert(record) {
            const norm = this.normalize(record);
            if (!norm) return null;
            this.loadAll();
            const idx = this._records.findIndex((r) => r.qHash === norm.qHash);
            if (idx >= 0) {
                const exist = this._records[idx];
                if (!exist.answer && norm.answer) exist.answer = norm.answer;
                if (norm.verified && !exist.verified) exist.verified = true;
                if (norm.answer && norm.answer !== exist.answer) {
                    // 答案冲突时保留已验证的，否则取新值
                    if (exist.verified) {
                        // 保持
                    } else {
                        exist.answer = norm.answer;
                    }
                }
                if (!exist.options || exist.options.length === 0) exist.options = norm.options;
                exist.updatedAt = new Date().toISOString();
            } else {
                this._records.push(norm);
            }
            this._writeAll(this._records);
            return norm;
        },

        findByHash(hash) {
            this.loadAll();
            if (!hash) return null;
            return this._records.find((r) => r.qHash === hash) || null;
        },

        // 模糊匹配：题目前 60 字符 + 选项数量相近
        findFuzzy(question, options) {
            this.loadAll();
            if (!question) return null;
            const prefix = String(question).slice(0, 60);
            const optCount = Array.isArray(options) ? options.length : 0;
            const candidates = this._records.filter((r) => {
                if (!r.question) return false;
                if (r.question.slice(0, 60) !== prefix) return false;
                if (optCount > 0 && Math.abs((r.options || []).length - optCount) > 1) return false;
                return true;
            });
            if (candidates.length === 0) return null;
            // 优先返回已验证的，其次返回最近的
            candidates.sort((a, b) => {
                if (a.verified !== b.verified) return a.verified ? -1 : 1;
                return (b.updatedAt || '').localeCompare(a.updatedAt || '');
            });
            return candidates[0];
        },

        // 兼容旧 API：按题干查找
        findByQuestion(question) {
            this.loadAll();
            if (!question) return null;
            return this._records.find((r) => r.question === question) || null;
        },

        count() {
            this.loadAll();
            return this._records.length;
        },

        all() {
            this.loadAll();
            return this._records.slice();
        },

        clear() {
            this._records = [];
            try { localStorage.removeItem(this.STORAGE_KEY); } catch (_) {}
            try { localStorage.removeItem(this.LEGACY_KEY); } catch (_) {}
            this._loaded = true;
        },

        exportJSON() {
            this.loadAll();
            return {
                __type: 'shuake-question-bank',
                version: 1,
                exportedAt: new Date().toISOString(),
                records: this._records.slice()
            };
        },

        importJSON(text, mergeMode = 'merge') {
            const data = SafeJSON.parse(text, null);
            if (!data) return { ok: false, inserted: 0, merged: 0, invalid: 0 };
            const raw = Array.isArray(data) ? data : (Array.isArray(data.records) ? data.records : []);
            let inserted = 0, merged = 0, invalid = 0;
            const incoming = [];
            for (const item of raw) {
                const norm = this.normalize(item);
                if (!norm) { invalid += 1; continue; }
                incoming.push(norm);
            }
            if (mergeMode === 'replace') {
                this._records = incoming.slice();
                inserted = incoming.length;
            } else {
                const before = this.count();
                this._records = this._mergeRecords(this._records, incoming);
                inserted = Math.max(0, this._records.length - before);
                merged = incoming.length - inserted;
            }
            this._writeAll(this._records);
            return { ok: true, inserted, merged, invalid, total: this._records.length };
        },

        // 命中记录（仅统计）
        recordHit(source) {
            if (this.stats[source] !== undefined) {
                this.stats[source] += 1;
                this._persistStats();
            }
        },

        // 按 qHash 删除单条题目（返回删除数量）
        removeRecord(qHash) {
            if (!qHash) return 0;
            this.loadAll();
            const before = this._records.length;
            this._records = this._records.filter((r) => r.qHash !== qHash);
            const removed = before - this._records.length;
            if (removed > 0) this._writeAll(this._records);
            return removed;
        },

        // 修改单条题目的答案（返回 true 表示成功）。
        // 传入标准答案字符串（如 "A" / "ABC" / "对"），自动规范化；
        // 修改后清除 verified 标记（答案已变更，原验证结论不再可靠）。
        updateAnswer(qHash, newAnswer) {
            if (!qHash) return false;
            const norm = String(newAnswer || '').trim().toUpperCase().slice(0, 64);
            if (!norm) return false;
            this.loadAll();
            let changed = false;
            for (const r of this._records) {
                if (r.qHash === qHash) {
                    if (r.answer === norm) {
                        // 答案未变化：仅刷新 updatedAt，仍视为一次有效操作
                        r.updatedAt = new Date().toISOString();
                    } else {
                        r.answer = norm;
                        r.updatedAt = new Date().toISOString();
                        // 答案已变，原"已验证"结论失效
                        r.verified = false;
                    }
                    changed = true;
                    break;
                }
            }
            if (changed) this._writeAll(this._records);
            return changed;
        }
    };

    // ========== 云端账户（独立登录态，与站点 x-token 分离） ==========
    // 存储结构 {token, user, expiresAt, lastRefresh}，独立于 CONFIG，避免 GM 配置同步时互相覆盖
    const CloudAuth = {
        STORAGE_KEY: 'shuake_cloud_auth_v1',
        _state: { token: null, user: null, expiresAt: 0, lastRefresh: 0 },

        // ---- 持久化 ----
        load() {
            // 登录态用 GM 存储持久化（跨 origin 共享：weiban 顶层 / mcwk iframe 实例共用一份），
            // 兼容旧版本 localStorage 存储的数据回退读取。
            try {
                let obj = gmReadJSON(this.STORAGE_KEY, null);
                if (!obj) {
                    try {
                        const raw = localStorage.getItem(this.STORAGE_KEY);
                        if (raw) obj = SafeJSON.parse(raw, null);
                    } catch (_) {}
                }
                if (obj && typeof obj === 'object') {
                    this._state.token = obj.token || null;
                    this._state.user = obj.user || null;
                    this._state.expiresAt = obj.expiresAt || 0;
                    this._state.lastRefresh = obj.lastRefresh || 0;
                }
            } catch (_) {}
        },

        save() {
            const payload = {
                token: this._state.token,
                user: this._state.user,
                expiresAt: this._state.expiresAt,
                lastRefresh: this._state.lastRefresh,
            };
            try { gmWriteJSON(this.STORAGE_KEY, payload); } catch (_) {}
            try { localStorage.setItem(this.STORAGE_KEY, JSON.stringify(payload)); } catch (_) {}
        },

        clear() {
            this._state.token = null;
            this._state.user = null;
            this._state.expiresAt = 0;
            this._state.lastRefresh = 0;
            try { GM_deleteValue(this.STORAGE_KEY); } catch (_) {}
            try { localStorage.removeItem(this.STORAGE_KEY); } catch (_) {}
        },

        // ---- 状态查询 ----
        isLoggedIn() {
            return !!(this._state.token && this._state.expiresAt > Date.now());
        },

        getToken() { return this._state.token; },
        getUser() { return this._state.user; },

        // 是否游客/自动注册账号（微伴身份自动注册，account_type=guest_auto / role=guest）：
        // 游客账号可用官方题库答题，但禁用充值 AI 答题（/api/ai/query）
        isGuestAccount() {
            try {
                const u = this._state.user || {};
                // 与后端对齐：游客自动注册账号 AccountType=guest（官方题库每日限额，禁用充值 AI）
                if (u.account_type === 'guest' || u.account_type === 'guest_auto' || u.account_type === 'weiban_auto') return true;
                if (u.role === 'guest') return true;
                return false;
            } catch (_) { return false; }
        },

        // ---- 内部 fetch（带 Bearer） ----
        async _fetchJSON(url, options = {}, timeoutMs = 8000) {
            const cfg = CloudBank ? CloudBank.getConfig() : {};
            const endpoint = cfg.endpoint || 'http://api.mk.heymeta.cn';
            const base = String(endpoint).replace(/\/+$/, '');
            const fullUrl = url.startsWith('http') ? url : (base + url);
            try {
                const resp = await HttpUtil.request(fullUrl, {
                    method: options.method || 'POST',
                    headers: Object.assign({
                        'Content-Type': 'application/json',
                        'Authorization': 'Bearer ' + (this._state.token || ''),
                    }, options.headers || {}),
                    body: options.body,
                    timeout: timeoutMs,
                });
                const text = await resp.text();
                return SafeJSON.parse(text, null);
            } catch (e) {
                if (e?.name === 'AbortError') throw new Error('请求超时');
                // 网络层失败（连接被拒/服务未启动/混合内容拦截）时给出可操作提示
                if (e instanceof TypeError || /fetch|network|load failed|ERR_|网络错误|请求超时/i.test(String(e && e.message))) {
                    throw new Error('无法连接云端服务（' + base + '），请确认后端已启动，或在「设置-云端题库」中修改服务地址');
                }
                throw e;
            }
        },

        // ---- API 方法 ----
        // 后端统一响应 {code,message,data:{...}}：成功时 payload 在 data 里
        _unwrap(data) {
            if (data && typeof data === 'object' && data.data && typeof data.data === 'object') {
                // 仅当 data 内确有业务字段时才解包；错误响应（无 data 或 data 为空）保持原样
                if (data.code === 0 || data.data.token || data.data.user || data.data.ok !== undefined) {
                    return data.data;
                }
            }
            return data;
        },

        async sendRegisterCode({ email }) {
            try {
                const data = await this._fetchJSON('/api/auth/send-register-code', {
                    method: 'POST',
                    body: JSON.stringify({ email }),
                });
                if (data && data.code === 0) {
                    return { ok: true, message: data.message || '验证码已发送' };
                }
                return { ok: false, error: data?.message || '发送失败' };
            } catch (e) {
                return { ok: false, error: e?.message || '网络错误' };
            }
        },

        async register({ email, password, username, emailCode }) {
            try {
                const data = await this._fetchJSON('/api/auth/register', {
                    method: 'POST',
                    body: JSON.stringify({ email, password, username: username || '', email_code: emailCode || '' }),
                });
                const d = this._unwrap(data);
                if (d && d.token && d.user) {
                    this._state.token = d.token;
                    this._state.user = d.user;
                    this._state.expiresAt = Date.now() + 7 * 24 * 3600 * 1000; // 7 天
                    this._state.lastRefresh = Date.now();
                    this.save();
                    return { ok: true, user: d.user };
                }
                return { ok: false, error: data?.message || '注册失败' };
            } catch (e) {
                return { ok: false, error: e?.message || '网络错误' };
            }
        },

        async login({ email, password }) {
            try {
                const data = await this._fetchJSON('/api/auth/login', {
                    method: 'POST',
                    body: JSON.stringify({ email, password }),
                });
                const d = this._unwrap(data);
                if (d && d.token && d.user) {
                    this._state.token = d.token;
                    this._state.user = d.user;
                    this._state.expiresAt = Date.now() + 7 * 24 * 3600 * 1000;
                    this._state.lastRefresh = Date.now();
                    this.save();
                    return { ok: true, user: d.user };
                }
                return { ok: false, error: data?.message || '登录失败' };
            } catch (e) {
                return { ok: false, error: e?.message || '网络错误' };
            }
        },

        async logout() {
            this.clear();
            // 用户主动退出：写"不再自动注册游客"标记（阻止刷新/重启后被 autoRegisterLogin 重新注册成游客）
            try { GM_setValue('sk_cloud_opt_out', '1'); } catch (_) {}
            try { if (typeof localStorage !== 'undefined') localStorage.setItem('sk_cloud_opt_out', '1'); } catch (_) {}
            try {
                const el = document.getElementById('shuake-early-notice');
                if (el) { el.style.opacity = '0'; setTimeout(() => { try { el.remove(); } catch (_) {} }, 500); }
            } catch (_) {}
            try { Logger.info('云端账户已退出'); } catch (_) {}
        },

        async getProfile() {
            try {
                const data = await this._fetchJSON('/api/profile', { method: 'GET' });
                if (data && data.data) {
                    this._state.user = data.data;
                    this.save();
                    return { ok: true, user: data.data };
                }
                return { ok: false };
            } catch (e) {
                return { ok: false, error: e?.message || '获取用户信息失败' };
            }
        },
    };
    // 启动时恢复云端账户登录态（必须在 CloudAuth 定义之后调用，避免 const TDZ）
    try { CloudAuth.load(); } catch (_) {}

    // ========== 游客学习进度上报（无需云端登录，供管理员统计用户/进度） ==========
    // 服务端契约（需后端配套放行，详见末尾说明）：
    //   POST {endpoint}/api/study/guest-report
    //   Header: X-Guest-Id: <游客唯一标识>（必填，服务端据此识别游客，不校验 Bearer）
    //            X-Site-Token: <站点 x-token>（可选，站点身份可信校验）
    //   Body:    course_name/page_turns/duration/status + guest_id + site_info
    //   site_info = {user_project_id, tenant_code, user_id, user_name, site}
    //   服务端按 guest_id 去重统计"用户数量"，按 site_info 归属项目/租户统计学习进度。
    const GuestReporter = {
        isEnabled() {
            try { return !!(CONFIG.cloudBank && CONFIG.cloudBank.guestReport); } catch (_) { return false; }
        },

        // 稳定游客标识：跨会话不变（GM + localStorage 双写），管理员据此统计用户数量
        getId() {
            try {
                let id = '';
                try { id = gmReadJSON('shuake_guest_id', '') || ''; } catch (_) {}
                if (!id && typeof localStorage !== 'undefined') {
                    try { id = localStorage.getItem('shuake_guest_id') || ''; } catch (_) {}
                }
                if (!id) {
                    id = 'guest_' + Math.random().toString(16).slice(2, 10) + Date.now().toString(16).slice(-8);
                    try { gmWriteJSON('shuake_guest_id', id); } catch (_) {}
                    try { if (typeof localStorage !== 'undefined') localStorage.setItem('shuake_guest_id', id); } catch (_) {}
                }
                return id;
            } catch (_) { return ''; }
        },

        // 站点身份快照（管理员统计归属：项目 / 租户 / 站点用户）
        _siteIdentity() {
            try {
                let info = null;
                try { if (typeof ProjectInfo !== 'undefined') ProjectInfo.parseURL(); info = ProjectInfo; } catch (_) {}
                let u = null;
                try { if (typeof readStoredUser === 'function') u = readStoredUser(); } catch (_) {}
                let uname = '';
                try {
                    uname = (info && info.userName) || (u && (u.realName || u.name || u.nickName || u.nickname)) || '';
                } catch (_) {}
                // 微伴 my/index.do 真实姓名缓存优先（已获取过则用 realName）
                try {
                    const _wp = (typeof State !== 'undefined') ? State._weibanProfile : null;
                    if (_wp && _wp.real_name && !uname) uname = _wp.real_name;
                } catch (_) {}
                return {
                    user_project_id: (info && info.userProjectId) || '',
                    tenant_code: (info && info.tenantCode) || '',
                    user_id: (info && info.userId) ? String(info.userId) : '',
                    user_name: String(uname || '').substring(0, 64),
                    site: (typeof location !== 'undefined' && location.hostname) || 'weiban.mycourse.cn'
                };
            } catch (_) { return {}; }
        },

        // 游客上报（独立请求，不带 Bearer，凭 X-Guest-Id 识别）
        async report(payload) {
            try {
                if (!this.isEnabled()) return null;
                const id = this.getId();
                if (!id) return null;
                const headers = { 'Content-Type': 'application/json', 'X-Guest-Id': id };
                // 站点 x-token 兜底（可选，增强身份可信）
                try {
                    if (typeof DataBridge !== 'undefined' && typeof DataBridge.getAuthToken === 'function') {
                        const tk = DataBridge.getAuthToken();
                        if (tk) headers['X-Site-Token'] = tk;
                    }
                } catch (_) {}
                const body = Object.assign({}, payload, { guest_id: id, site_info: this._siteIdentity() });
                const cfg = (typeof CloudBank !== 'undefined') ? CloudBank.getConfig() : {};
                const base = (cfg && cfg.endpoint) || 'http://api.mk.heymeta.cn';
                const url = String(base).replace(/\/+$/, '') + '/api/study/guest-report';
                const resp = await HttpUtil.request(url, {
                    method: 'POST', headers, body: JSON.stringify(body), timeout: 10000,
                });
                const text = await resp.text();
                const data = SafeJSON.parse(text, null);
                if (data && data.code === 0) {
                    // 返回完整响应（含 code:0），让 StudyReporter.report 的 `data.code === 0` 判断命中，
                    // 从而正确置位 State.studyReported（completed/failed 防重）。
                    // 修复前返回 data.data（无 code）→ 判断永 false → 同一课 completed 每轮循环重复上报、
                    // 服务端每日统计重复累加。
                    return { code: 0, data: (data.data && typeof data.data === 'object') ? data.data : {} };
                }
                if (resp.status === 401) {
                    try { Logger.warning('[游客上报] 服务端未开放游客上报（401），需后端放行 POST /api/study/guest-report'); } catch (_) {}
                    return null;
                }
                try { Logger.debug(`[游客上报] 服务端返回异常: ${text && String(text).substring(0, 200)}`); } catch (_) {}
                return null;
            } catch (e) {
                try { Logger.debug(`[游客上报] 失败: ${e?.message || e}`); } catch (_) {}
                return null;
            }
        }
    };

    // ========== 微伴游客账号系统（自动注册登录 + 数据绑定合并 + 权限控制） ==========
    // 目标：游客也能上传学习进度供管理员统计，且体验尽量自动化。
    // 流程：
    //   1) 自动设备唯一识别号（GuestReporter.getId，guest_xxx，GM+localStorage 持久化跨会话不变）
    //   2) 采集微伴平台身份（姓名/昵称/userId/tenantCode/userProjectId）
    //   3) 未登录时自动调用 POST /api/auth/weiban-login：服务端凭 X-Site-Token + 微伴身份
    //      免验证码自动注册并登录（返回 account_type='guest_auto' 的账号），token 持久化（CloudAuth）
    //   4) 自动注册登录成功后自动调用 POST /api/study/merge-guest：把该 guest_id 此前的
    //      游客上报记录合并到账号名下（用户也可在面板手动触发"合并游客数据"）
    // 权限：
    //   - 游客/自动注册账号（account_type=guest_auto / role=guest）：可用官方题库答题，禁用充值 AI（/api/ai/query）
    //   - 正式账号（邮箱注册）：全部可用
    // 服务端契约（需后端配套放行，脚本端已实现调用）：
    //   POST {endpoint}/api/auth/weiban-login   Header: X-Guest-Id + X-Site-Token；Body: {user_id,tenant_code,user_project_id,name}
    //   POST {endpoint}/api/study/merge-guest   Header: Authorization(Bearer JWT) + X-Guest-Id；Body: {guest_id}
    const WeibanAutoAuth = {
        _tried: false,      // 会话内是否已尝试自动注册登录（防重复请求）

        // 是否启用自动注册（未登录 + 游客上报开启 + 云端端点已配置）
        isEnabled() {
            try {
                if (typeof CloudAuth === 'undefined' || typeof GuestReporter === 'undefined') return false;
                if (CloudAuth.isLoggedIn()) return false;
                // 开关：关闭"自动注册游客账号登录"后不再自动登录游客（仍可游客上报）
                try {
                    if (CONFIG.cloudBank && CONFIG.cloudBank.autoGuestLogin === false) return false;
                } catch (_) {}
                // 用户主动退出登录标记（CloudAuth.logout 写入）→ 不再自动注册游客，
                // 否则退出后刷新页面又被自动注册成游客，永远无法切换正式账号。
                try {
                    let _oo = '';
                    try { _oo = String(GM_getValue('sk_cloud_opt_out', '') || ''); } catch (_) {}
                    if (!_oo && typeof localStorage !== 'undefined') _oo = String(localStorage.getItem('sk_cloud_opt_out') || '');
                    if (_oo === '1') return false;
                } catch (_) {}
                return GuestReporter.isEnabled();
            } catch (_) { return false; }
        },

        // 采集微伴平台身份（姓名/昵称/站点用户标识）
        collectIdentity() {
            try {
                let u = null;
                try { if (typeof readStoredUser === 'function') u = readStoredUser(); } catch (_) {}
                let info = null;
                try { if (typeof ProjectInfo !== 'undefined') ProjectInfo.parseURL(); info = ProjectInfo; } catch (_) {}
                let name = '';
                try { name = (u && (u.realName || u.name || u.nickName || u.nickname)) || ''; } catch (_) {}
                return {
                    user_id: (info && info.userId) || (u && u.userId) || '',
                    tenant_code: (info && info.tenantCode) || (u && u.tenantCode) || '',
                    user_project_id: (info && info.userProjectId) || (u && u.userProjectId) || '',
                    name: String(name || '').substring(0, 64),
                    site: (typeof location !== 'undefined' && location.hostname) || 'weiban.mycourse.cn'
                };
            } catch (_) { return {}; }
        },

        // 云端端点基础地址
        _base() {
            try {
                const cfg = (typeof CloudBank !== 'undefined') ? CloudBank.getConfig() : {};
                return String((cfg && cfg.endpoint) || 'http://api.mk.heymeta.cn').replace(/\/+$/, '');
            } catch (_) { return 'http://api.mk.heymeta.cn'; }
        },

        // 站点 x-token（可选，服务端身份可信校验）
        _siteToken() {
            try {
                if (typeof DataBridge !== 'undefined' && typeof DataBridge.getAuthToken === 'function') {
                    const tk = DataBridge.getAuthToken();
                    return tk || '';
                }
            } catch (_) {}
            return '';
        },

        // 微伴个人信息获取：模拟 POST pharos/my/index.do（表单 tenantCode+userId），
        // 返回 realName(真实姓名) / tenantName(学校) / userIDLabel(学号)，供自动注册带真实身份。
        // 响应示例：{"code":"0","data":{"realName":"胡艺博","userIDLabel":"学号：20260732","tenantName":"武汉学院",...}}
        async fetchWeibanProfile(tenantCode, userId) {
            try {
                if (!tenantCode || !userId) return null;
                const headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
                try {
                    if (typeof DataBridge !== 'undefined' && typeof DataBridge.getAuthToken === 'function') {
                        const tk = DataBridge.getAuthToken();
                        if (tk) headers['X-Token'] = tk;
                    }
                } catch (_) {}
                try {
                    const st = this._siteToken();
                    if (st && !headers['X-Token']) headers['X-Token'] = st;
                } catch (_) {}
                try {
                    if (typeof readStoredToken === 'function') {
                        const tk = readStoredToken();
                        if (tk && !headers['X-Token']) headers['X-Token'] = tk;
                    }
                } catch (_) {}
                try { if (window.__authToken && !headers['X-Token']) headers['X-Token'] = window.__authToken; } catch (_) {}
                const resp = await HttpUtil.request(
                    'https://weiban.mycourse.cn/pharos/my/index.do?timestamp=' + (Date.now() / 1000),
                    { method: 'POST', headers: headers,
                      body: 'tenantCode=' + encodeURIComponent(tenantCode) + '&userId=' + encodeURIComponent(userId),
                      timeout: 8000 }
                );
                const text = await resp.text();
                const data = SafeJSON.parse(text, null);
                const d = (data && data.data) || null;
                if (data && String(data.code) === '0' && d) {
                    const profile = {
                        real_name: String(d.realName || '').substring(0, 64),
                        tenant_name: String(d.tenantName || '').substring(0, 64),
                        user_id_label: String(d.userIDLabel || '').substring(0, 64),
                    };
                    try { State._weibanProfile = profile; } catch (_) {}
                    try { Logger.info(`[微伴信息] 已获取：${profile.real_name || '?'}（${profile.tenant_name || '?'}）`); } catch (_) {}
                    return profile;
                }
                try { Logger.debug('[微伴信息] my/index.do 未返回有效数据（可能缺 X-Token）'); } catch (_) {}
                return null;
            } catch (e) {
                try { Logger.debug(`[微伴信息] 获取失败: ${e?.message || e}`); } catch (_) {}
                return null;
            }
        },

        // 采集微伴身份（基础字段）+ 模拟 my/index.do 获取真实姓名/学校（增强）
        async collectIdentityWithProfile() {
            const ident = this.collectIdentity();
            try {
                const p = await this.fetchWeibanProfile(ident.tenant_code, ident.user_id);
                if (p) {
                    if (p.real_name && !ident.name) ident.name = p.real_name;
                    if (p.tenant_name) ident.tenant_name = p.tenant_name;
                    if (p.user_id_label) ident.user_id_label = p.user_id_label;
                }
            } catch (_) {}
            return ident;
        },

        // 自动注册并登录（用微伴身份；服务端未实现时静默降级，不影响游客上报）
        async autoRegisterLogin() {
            try {
                if (!this.isEnabled()) return null;
                if (this._tried) return null;
                this._tried = true;
                const ident = await this.collectIdentityWithProfile();
                if (!ident.user_id && !ident.tenant_code && !ident.user_project_id) {
                    try { Logger.debug('[自动注册] 无微伴身份信息，跳过自动注册'); } catch (_) {}
                    return null;
                }
                const guestId = (typeof GuestReporter !== 'undefined') ? GuestReporter.getId() : '';
                const headers = { 'Content-Type': 'application/json' };
                if (guestId) headers['X-Guest-Id'] = guestId;
                const st = this._siteToken();
                if (st) headers['X-Site-Token'] = st;
                const resp = await HttpUtil.request(this._base() + '/api/auth/weiban-login', {
                    method: 'POST', headers, body: JSON.stringify(ident), timeout: 12000,
                });
                const text = await resp.text();
                const data = SafeJSON.parse(text, null);
                if (resp.status === 401 || resp.status === 404) {
                    try { Logger.warning('[自动注册] 服务端未开放微伴自动注册（HTTP ' + resp.status + '），需后端实现 POST /api/auth/weiban-login'); } catch (_) {}
                    return null;
                }
                const d = (data && data.data && typeof data.data === 'object') ? data.data : data;
                if (d && d.token && d.user) {
                    CloudAuth._state.token = d.token;
                    CloudAuth._state.user = d.user;
                    CloudAuth._state.expiresAt = Date.now() + 7 * 24 * 3600 * 1000;
                    CloudAuth._state.lastRefresh = Date.now();
                    CloudAuth.save();
                    try {
                        const nm = d.user.name || d.user.username || d.user.email || '游客账号';
                        Logger.info('✅ 已用微伴身份自动注册并登录云端（' + nm + '，自动登录已持久化）');
                    } catch (_) {}
                    // 自动把游客数据合并到新账号
                    this.mergeGuestData(guestId);
                    return { ok: true, user: d.user };
                }
                try { Logger.debug(`[自动注册] 服务端返回异常: ${text && String(text).substring(0, 200)}`); } catch (_) {}
                return null;
            } catch (e) {
                try { Logger.debug(`[自动注册] 失败: ${e?.message || e}`); } catch (_) {}
                return null;
            }
        },

        // 把游客数据绑定合并到已登录账号（服务端按 guest_id 关联上报记录）
        async mergeGuestData(guestId) {
            try {
                if (typeof CloudAuth === 'undefined' || !CloudAuth.isLoggedIn()) return null;
                const id = guestId || ((typeof GuestReporter !== 'undefined') ? GuestReporter.getId() : '');
                if (!id) return null;
                const headers = {
                    'Content-Type': 'application/json',
                    'Authorization': 'Bearer ' + (CloudAuth.getToken() || ''),
                    'X-Guest-Id': id,
                };
                const resp = await HttpUtil.request(this._base() + '/api/study/merge-guest', {
                    method: 'POST', headers, body: JSON.stringify({ guest_id: id }), timeout: 12000,
                });
                const text = await resp.text();
                const data = SafeJSON.parse(text, null);
                if (resp.status === 401 || resp.status === 404) {
                    try { Logger.debug('[合并] 服务端未开放游客数据合并（HTTP ' + resp.status + '），需后端实现 POST /api/study/merge-guest'); } catch (_) {}
                    return null;
                }
                if (data && data.code === 0) {
                    try { Logger.info('[合并] 游客数据已合并到账号（guest_id=' + id + '）'); } catch (_) {}
                    return (data.data && typeof data.data === 'object') ? data.data : {};
                }
                return null;
            } catch (e) {
                try { Logger.debug(`[合并] 失败: ${e?.message || e}`); } catch (_) {}
                return null;
            }
        }
    };

    // ========== 刷课状态上报（已登录云端账号用 JWT，游客用 X-Guest-Id） ==========
    // 已登录（CloudAuth.isLoggedIn()）→ /api/study/report（Bearer）；
    // 未登录但启用游客上报（CONFIG.cloudBank.guestReport）→ /api/study/guest-report（X-Guest-Id）。
    // 认证复用 CloudAuth 的 JWT（Authorization: Bearer），Base = 云端端点（api.mk.heymeta.cn）。
    // 流程：翻页计数（Statistics.recordPageView 统一 +1）→ 课程完成（图文 completeCourseByV2 /
    // 视频 handleVideoComplete）POST /api/study/report 一次（completed）；用户手动停止 POST running。
    const StudyReporter = {
        // 本课是否已进入刷课计时
        started() { return !!State.studyStartedAt; },

        // 课程名兜底解析（ensureStarted 快照与 report 上报前共用）：
        // ① URL courseName 参数 → ② GM 存储 sk_course_name（宿主页 hashchange 写入，跨域共享）
        // ③ document.title 清洗 → ④ 课件页 h2 标题。解析成功回写 GM，保证记录课程名不落空。
        _resolveCourseName() {
            let _cn = State.currentCourseName || '';
            if (_cn && _cn !== '未知课程' && _cn !== '未知' && _cn !== '未命名课程') return _cn;
            try {
                let _n = '';
                try {
                    const _q = new URLSearchParams((typeof location !== 'undefined' && location.search) || '').get('courseName');
                    if (_q) _n = decodeURIComponent(_q);
                } catch (_) {}
                if (!_n) {
                    try {
                        const _h = (typeof location !== 'undefined' && location.hash) || '';
                        const _qi = _h.indexOf('?');
                        if (_qi >= 0) _n = decodeURIComponent(new URLSearchParams(_h.slice(_qi + 1)).get('courseName') || '');
                    } catch (_) {}
                }
                if (!_n) {
                    try {
                        const _gm = (typeof GM_getValue === 'function') ? GM_getValue('sk_course_name', '') : '';
                        if (_gm) _n = String(_gm).trim();
                    } catch (_) {}
                }
                if (!_n && typeof document !== 'undefined' && document.title) {
                    _n = String(document.title).replace(/\s*[-_—|·]\s*/g, ' ').replace(/\s+/g, ' ').trim();
                    _n = _n.replace(/\s*(麦课在线|微信学习平台|在线学习平台).*$/i, '').trim();
                }
                if (!_n) {
                    try {
                        const _h2 = document.querySelector('h2, .course-title, .video-title, [class*=title]');
                        if (_h2 && _h2.textContent) _n = String(_h2.textContent).replace(/\s+/g, ' ').trim();
                    } catch (_) {}
                }
                if (_n && _n !== 'undefined') {
                    State.currentCourseName = _n;
                    try { if (typeof GM_setValue === 'function') GM_setValue('sk_course_name', _n); } catch (_) {}
                    try { Logger.debug(`[上报] 课程名解析: ${_n}`); } catch (_) {}
                    return _n;
                }
            } catch (_) {}
            return _cn;
        },

        // 惰性初始化本课开始时间（首次翻页 / 完成上报时触发；未登录云端则跳过）
        // 本系统 API Key（面板"API 密钥"页生成，X-API-Key 头鉴权，免登录；对齐刷课统计 API 文档）
        _apiKey() {
            try {
                const k = (CONFIG && CONFIG.cloudBank && CONFIG.cloudBank.apiKey) || '';
                return String(k).trim();
            } catch (_) { return ''; }
        },

        ensureStarted() {
            try {
                if (State.studyStartedAt) return;
                // 【一课一报防重】本课已完成上报（report 成功后 studyStartedAt 已归零）且当前仍是同一课程
                // （studyCourseName === currentCourseName）→ 不重新计时，避免并发/重复触发把 studyReported
                // 重置回 false 导致同课重复上报（实测 8 条重复记录）。
                // 课程名已变化（切课未触发 resetForNewCourse）→ 视为新课，重新计时。
                if (State.studyReported && State.studyCourseName && State.currentCourseName &&
                    State.studyCourseName === State.currentCourseName) return;
                const apiKey = this._apiKey();
                const authed = (apiKey !== '') || (typeof CloudAuth !== 'undefined' && CloudAuth.isLoggedIn());
                const guest = (!authed && typeof GuestReporter !== 'undefined' && GuestReporter.isEnabled());
                if (!authed && !guest) {
                    try { Logger.debug('[上报] ensureStarted 跳过：无 API Key / 未登录 / 游客未启用'); } catch (_) {}
                    return;
                }
                State.studyStartedAt = Date.now();
                State.studyPageTurns = 0;
                State.studyReported = false;
                State.studyReportId = null;
                State.studyStatus = 'running';
                State.studyCourseName = this._resolveCourseName();
                try { Logger.debug(`[上报] 开始记录刷课状态（课程: ${State.studyCourseName || '未知'}）`); } catch (_) {}
                // 对齐 v1.2：启动 60s 心跳（API Key / JWT 用户），维持"最后活跃"状态
                try { this.startHeartbeat(); } catch (_) {}
            } catch (_) {}
        },

        // 翻页计数（由 Statistics.recordPageView 统一调用）
        countPageTurn() {
            try {
                if (State.studyStartedAt) State.studyPageTurns = (State.studyPageTurns || 0) + 1;
            } catch (_) {}
        },

        // 上报一条刷课记录；status: running / completed / failed
        // completed / failed 每课只 POST 一次（防重，避免服务端每日统计 +1 重复累加）
        async report(status = 'running') {
            try {
                const apiKey = this._apiKey();
                const authed = (apiKey !== '') || (typeof CloudAuth !== 'undefined' && CloudAuth.isLoggedIn());
                const guest = (!authed && typeof GuestReporter !== 'undefined' && GuestReporter.isEnabled());
                if (!authed && !guest) {
                    try { Logger.debug('[上报] report 跳过：无 API Key / 未登录 / 游客未启用'); } catch (_) {}
                    return null;
                }
                if (!State.studyStartedAt) this.ensureStarted();
                if (!State.studyStartedAt) {
                    try { Logger.debug('[上报] 刷课未开始计时（ensureStarted 未启动），跳过上报'); } catch (_) {}
                    return null;
                }
                const _isFinal = (status === 'completed' || status === 'failed');
                if (_isFinal && State.studyReported) return null;
                // 【防重·乐观置位】finishWxCourse 同帧可能多次触发（站点监听链 + 脚本 hook 多路），
                // 防重标记必须在上报请求发出前置位，否则并发请求会重复生成多条记录（实测同课 4 条 107-110）。
                if (_isFinal) State.studyReported = true;
                const duration = Math.floor((Date.now() - State.studyStartedAt) / 1000);
                let _cn = this._resolveCourseName();

                const payload = {
                    course_name: _cn,
                    page_turns: State.studyPageTurns || 0,
                    duration: duration >= 0 ? duration : 0,
                    status: status || 'running',
                    extra_data: JSON.stringify({
                        mode: 'auto',
                        ua: (typeof navigator !== 'undefined' && navigator.userAgent) ? String(navigator.userAgent).substring(0, 300) : '',
                        page: (typeof location !== 'undefined' && location.href) ? String(location.href).substring(0, 200) : ''
                    })
                };
                // 【防重·GM 跨实例】iframe/脚本重载会生成新 State（studyReported 不跨实例），
                // 同一课程完成上报后 5s 内再次上报直接跳过（GM 存储跨域共享，宿主页/课件页同 key）。
                if (_isFinal) {
                    try {
                        const _nowG = Date.now();
                        const _lastG = (typeof GM_getValue === 'function') ? GM_getValue('sk_last_report', null) : null;
                        if (_lastG && _lastG.course === payload.course_name && (_nowG - (_lastG.ts || 0)) < 5000) {
                            try { Logger.debug(`[上报] 5s 内同课程已上报（${payload.course_name}），跳过防重`); } catch (_) {}
                            if (_isFinal) State.studyReported = false;
                            return null;
                        }
                    } catch (_) {}
                }
                // 认证优先级：本系统 API Key（X-API-Key 头，免登录不干扰刷课）→ JWT → 游客
                const data = (apiKey !== '')
                    ? await CloudBank._fetchJSON('/api/study/report', { method: 'POST', headers: { 'X-API-Key': apiKey }, body: JSON.stringify(payload) }, 10000)
                    : (authed
                        ? await CloudAuth._fetchJSON('/api/study/report', { method: 'POST', body: JSON.stringify(payload) }, 10000)
                        : await GuestReporter.report(payload));
                if (data && data.code === 0) {
                    // studyReported 已在上报前乐观置位（final 状态）
                    if (data.data && data.data.id != null) State.studyReportId = data.data.id;
                    State.studyStatus = status;
                    // GM 跨实例防重记录（成功后才写，失败不记录 → 允许重试）
                    if (_isFinal) {
                        try { if (typeof GM_setValue === 'function') GM_setValue('sk_last_report', { course: payload.course_name, ts: Date.now() }); } catch (_) {}
                    }
                    // 【一课一报】完成/失败上报成功后重置计时起点，避免下一课 duration 跨课累计。
                    // （resetForNewCourse 依赖 hashchange 切课检测；若该检测未触发则 studyStartedAt 保留
                    // 上一课旧值 → 下一课 duration 虚高，实测 1322s 实为跨 22 分钟累计）
                    if (_isFinal) State.studyStartedAt = null;
                    try { Logger.info(`[上报] 刷课状态已上报 ${payload.status}（翻页 ${payload.page_turns} 次，用时 ${payload.duration}s）`); } catch (_) {}
                    // 对齐 v1.2：完成/失败后停止心跳，并补一次对应状态心跳（维持最新 last_study_status）
                    try { this.stopHeartbeat(); this.heartbeat(State.studyCourseName || State.currentCourseName || '', status); } catch (_) {}
                    return (data.data && typeof data.data === 'object') ? data.data : {};
                }
                try {
                    let _diag = '';
                    try {
                        const _d = (typeof CloudBank !== 'undefined') ? CloudBank._lastDiag : null;
                        if (_d) _diag = ` | http=${_d.status} url=${_d.url} body=${_d.body || ''}`;
                    } catch (_) {}
                    Logger.debug(`[上报] 上报失败 code=${data && data.code} msg=${data && data.message}${_diag}`);
                } catch (_) {}
                if (_isFinal) State.studyReported = false;
                return null;
            } catch (e) {
                try {
                    let _diag = '';
                    try {
                        const _d = (typeof CloudBank !== 'undefined') ? CloudBank._lastDiag : null;
                        if (_d) _diag = ` | http=${_d.status} url=${_d.url} body=${_d.body || ''} err=${_d.error || ''}`;
                    } catch (_) {}
                    Logger.debug(`[上报] 上报异常: ${(e && e.message) || e}${_diag}`);
                } catch (_) {}
                if (_isFinal) State.studyReported = false;
                return null;
            }
        },

        // 增量更新已有记录（对齐文档 4.2：page_turns/duration 为当前累计值，服务端覆盖；不重复累加每日统计）
        async update(id, pageTurns, duration, status = 'running') {
            try {
                if (!id) return null;
                const apiKey = this._apiKey();
                const authed = (apiKey !== '') || (typeof CloudAuth !== 'undefined' && CloudAuth.isLoggedIn());
                if (!authed) return null;
                const payload = { page_turns: pageTurns || 0, duration: duration || 0, status: status || 'running' };
                const data = (apiKey !== '')
                    ? await CloudBank._fetchJSON('/api/study/report/' + id, { method: 'PUT', headers: { 'X-API-Key': apiKey }, body: JSON.stringify(payload) }, 10000)
                    : await CloudAuth._fetchJSON('/api/study/report/' + id, { method: 'PUT', body: JSON.stringify(payload) }, 10000);
                if (data && data.code === 0) {
                    try { Logger.info(`[上报] 刷课记录已增量更新 #${id}（翻页 ${payload.page_turns}，用时 ${payload.duration}s）`); } catch (_) {}
                    return (data.data && typeof data.data === 'object') ? data.data : {};
                }
                return null;
            } catch (e) {
                try { Logger.debug(`[上报] 增量更新异常: ${(e && e.message) || e}`); } catch (_) {}
                return null;
            }
        },

        // ========== 心跳（对齐刷课统计 API v1.2：POST /api/study/heartbeat） ==========
        // 仅刷新 users.last_*，不写 study_records / 不累加 study_stats；游客无 heartbeat 端点（公开 guest-report 已覆盖）
        // 失败不重试、不阻塞主流程（文档 4.3）
        async heartbeat(courseName, status) {
            try {
                const apiKey = this._apiKey();
                const authed = (apiKey !== '') || (typeof CloudAuth !== 'undefined' && CloudAuth.isLoggedIn());
                if (!authed) return null;
                const payload = { status: status || 'running' };
                if (courseName) payload.course_name = String(courseName).substring(0, 200);
                const data = (apiKey !== '')
                    ? await CloudBank._fetchJSON('/api/study/heartbeat', { method: 'POST', headers: { 'X-API-Key': apiKey }, body: JSON.stringify(payload) }, 8000)
                    : await CloudAuth._fetchJSON('/api/study/heartbeat', { method: 'POST', body: JSON.stringify(payload) }, 8000);
                if (data && data.code === 0) {
                    try { Logger.debug(`[心跳] ${payload.status}${courseName ? ' ' + courseName : ''}`); } catch (_) {}
                    return true;
                }
                return null;
            } catch (e) {
                try { Logger.debug(`[心跳] 异常: ${(e && e.message) || e}`); } catch (_) {}
                return null;
            }
        },

        // 启动心跳：立即打一次 + 每 60s 一次，直到课程完成 / 手动停止
        startHeartbeat() {
            try {
                if (State.studyHeartbeatTimer) return; // 防重（同一课程不重复起定时器）
                const self = this;
                const tick = function (immediate) {
                    if (!State.studyStartedAt) { self.stopHeartbeat(); return; }
                    // 课程名变化：立刻带新 course_name 心跳（文档 4.3.4），否则管理后台只看到旧课程
                    const cur = State.currentCourseName || '';
                    if (immediate || (cur && cur !== State.studyCourseName)) {
                        State.studyCourseName = cur || State.studyCourseName || '';
                        self.heartbeat(State.studyCourseName, 'running');
                    }
                };
                tick(true);
                State.studyHeartbeatTimer = setInterval(function () { tick(false); }, 60000);
            } catch (_) {}
        },

        // 停止心跳（课程完成 / 手动停止 / 异常退出）
        stopHeartbeat() {
            try {
                if (State.studyHeartbeatTimer) {
                    clearInterval(State.studyHeartbeatTimer);
                    State.studyHeartbeatTimer = null;
                }
            } catch (_) {}
        }
    };

    // ========== 风控检测与上报（weiban 701 / access-denial） ==========
    // 701 = weiban 平台判定账号被风控（页面跳 /#/access-denial?status=701），
    // 此时所有 pharos API（showProgress/listPlan/listCourse 等）返回 HTTP 701。
    // 脚本自动暂停刷课（避免继续操作加重风控），并把风控数据上报到云端。
    const RiskControl = {
        _lastHandleTs: 0,   // 最近一次处理时间（5 分钟防重）
        _reported: false,   // 本次会话是否已上报云端（防重）

        handle701(status, url) {
            try {
                if (status !== 701) return;
                const now = Date.now();
                if (this._lastHandleTs && (now - this._lastHandleTs) < 5 * 60 * 1000) return;
                this._lastHandleTs = now;

                // 1) 自动暂停刷课（避免继续操作加重风控）+ 面板状态提示（无条件显示）
                try {
                    if (State.isRunning) {
                        State.isRunning = false;
                        State.isPaused = true;
                        try { gmWriteJSON('shuake_run_state', { isRunning: false, isPaused: true }); } catch (_) {}
                    }
                } catch (_) {}
                try {
                    if (window.shuakePanelInstance) {
                        if (window.shuakePanelInstance._state) window.shuakePanelInstance._state.running = false;
                        if (typeof window.shuakePanelInstance.updateStatus === 'function') {
                            window.shuakePanelInstance.updateStatus('⚠️ 账号被风控（701），已自动暂停', 'error');
                        }
                    }
                } catch (_) {}

                // 2) 日志 / 浮层提示
                try { Logger.error('⚠️ 检测到账号被风控（HTTP 701），已自动暂停刷课并上报风控数据'); } catch (_) {}
                try { showFloatToast('账号被风控（701），已自动暂停刷课', 'error', 4000); } catch (_) {}

                // 3) 上报云端（登录云端账号才生效）
                this.report(url);
            } catch (_) {}
        },

        async report(url) {
            try {
                if (typeof CloudAuth === 'undefined' || !CloudAuth.isLoggedIn()) return;
                if (this._reported) return;
                this._reported = true;
                let info = null;
                try { if (typeof ProjectInfo !== 'undefined') ProjectInfo.parseURL(); info = ProjectInfo; } catch (_) {}
                const payload = {
                    risk_type: 'weiban_701',
                    status: 701,
                    source_url: url || (typeof location !== 'undefined' ? location.href : ''),
                    user_project_id: (info && info.userProjectId) || (typeof ProjectInfo !== 'undefined' && ProjectInfo.userProjectId) || '',
                    tenant_code: (info && info.tenantCode) || (typeof ProjectInfo !== 'undefined' && ProjectInfo.tenantCode) || '',
                    detail: {
                        msg: 'weiban 账号被风控，pharos API 返回 701 (access-denial)',
                        page: (typeof location !== 'undefined' && location.href) ? String(location.href).substring(0, 300) : '',
                        ua: (typeof navigator !== 'undefined' && navigator.userAgent) ? String(navigator.userAgent).substring(0, 300) : ''
                    }
                };
                const data = await CloudAuth._fetchJSON('/api/study/risk', { method: 'POST', body: JSON.stringify(payload) }, 10000);
                try { Logger.info(`[上报] 风控数据已上报云端${(data && data.code === 0) ? '' : '（服务端未确认）'}`); } catch (_) {}
            } catch (_) {}
        }
    };

    // ========== HTTP 请求工具（优先 GM_xmlhttpRequest，绕过混合内容/CORS） ==========
    // 脚本运行在 https://weiban.mycourse.cn，云端默认 http://api.mk.heymeta.cn，
    // 原生 fetch 会被浏览器混合内容拦截；GM_xmlhttpRequest 不受此限制。
    const HttpUtil = {
        async request(url, options = {}) {
            const method = (options.method || 'GET').toUpperCase();
            const headers = options.headers || {};
            const body = options.body || null;
            const timeout = options.timeout || 8000;
            const signal = options.signal || null;

            // 优先 GM_xmlhttpRequest（油猴沙箱，绕过 CORS / 混合内容）
            if (typeof GM_xmlhttpRequest !== 'undefined') {
                return new Promise((resolve, reject) => {
                    let settled = false;
                    const abortErr = function () { return new Error('请求已取消'); };
                    const onSignalAbort = function () {
                        try { handle.abort(); } catch (_) {}
                        if (settled) return; settled = true;
                        reject(abortErr());
                    };
                    if (signal) {
                        if (signal.aborted) { onSignalAbort(); return; }
                        try { signal.addEventListener('abort', onSignalAbort); } catch (_) {}
                    }
                    const handle = GM_xmlhttpRequest({
                        method: method,
                        url: url,
                        headers: headers,
                        data: (method !== 'GET' && method !== 'HEAD') ? body : undefined,
                        timeout: timeout,
                        onload: function (resp) {
                            if (settled) return; settled = true;
                            try { if (signal) signal.removeEventListener('abort', onSignalAbort); } catch (_) {}
                            resolve({
                                status: resp.status,
                                ok: resp.status >= 200 && resp.status < 300,
                                text: async function () { return resp.responseText || ''; },
                            });
                        },
                        onerror: function () {
                            if (settled) return; settled = true;
                            try { if (signal) signal.removeEventListener('abort', onSignalAbort); } catch (_) {}
                            reject(new Error('网络错误'));
                        },
                        ontimeout: function () {
                            if (settled) return; settled = true;
                            try { if (signal) signal.removeEventListener('abort', onSignalAbort); } catch (_) {}
                            reject(new Error('请求超时'));
                        },
                        onabort: function () {
                            if (settled) return; settled = true;
                            try { if (signal) signal.removeEventListener('abort', onSignalAbort); } catch (_) {}
                            reject(abortErr());
                        },
                    });
                    // 兜底超时（部分引擎不触发 ontimeout）
                    setTimeout(function () {
                        if (settled) return; settled = true;
                        try { handle.abort(); } catch (_) {}
                        reject(new Error('请求超时'));
                    }, timeout + 500);
                });
            }

            // fallback：原生 fetch（https 页面发 http 可能被混合内容拦截）
            const controller = new AbortController();
            const timer = setTimeout(function () { try { controller.abort(); } catch (_) {} }, timeout);
            // 外部 signal 与内部超时合并取消
            if (signal) {
                if (signal.aborted) { controller.abort(); }
                else {
                    try {
                        signal.addEventListener('abort', function () {
                            try { controller.abort(); } catch (_) {}
                        });
                    } catch (_) {}
                }
            }
            try {
                const resp = await fetch(url, {
                    method: method,
                    headers: headers,
                    body: (method !== 'GET' && method !== 'HEAD') ? body : undefined,
                    credentials: 'omit',
                    signal: controller.signal,
                });
                clearTimeout(timer);
                return resp;
            } catch (e) {
                clearTimeout(timer);
                throw e;
            }
        }
    };

    // ========== 脚本版本检测（公开接口，无需认证） ==========
    // 拉取 GET /api/version 判断是否需要更新（服务端已实测可用；/api/version/check 未实现时 404）
    // 复用 CloudBank.endpoint（api.mk.heymeta.cn），不经过 CloudAuth（无需登录）
    const VersionChecker = {
        // 当前版本：优先 GM_info.script.version（油猴元数据），兜底硬编码
        current: String((typeof GM_info !== 'undefined' && GM_info.script && GM_info.script.version) || '2.48').trim(),
        channel: 'stable',

        // 提取版本字符串中的首个数字段（兼容 "V-0.01 Beta" / "2.48" / "1.2.0"）
        _num(version) {
            const m = String(version || '').match(/\d+(\.\d+)*/);
            if (!m) return null;
            const parts = m[0].split('.').map((p) => parseInt(p, 10) || 0);
            while (parts.length < 3) parts.push(0);
            return parts[0] * 1000000 + parts[1] * 1000 + parts[2];
        },

        // 本地是否落后于远端（远端数字 > 本地数字）
        _isBehind(local, remote) {
            const a = this._num(local), b = this._num(remote);
            if (a == null || b == null) return false; // 无法解析则视为无需更新
            return b > a;
        },

        // 云端检查更新（v1.2：/api/version/check 全字段解析；channel + current 传给服务端做阈值判定）
        // 返回结构与指南 §三.1 对齐：needUpdate/force/latest/current/channel/changelog/downloadUrl/fallbackUrl/fileSha256/fileSize/minClientVersion/reason
        async check(channel) {
            try {
                const ch = (channel || this.channel || 'stable');
                const cfg = (typeof CloudBank !== 'undefined' && typeof CloudBank.getConfig === 'function')
                    ? CloudBank.getConfig() : {};
                const endpoint = (cfg.endpoint || 'http://api.mk.heymeta.cn').replace(/\/+$/, '');
                const current = String(this.current || '').trim();
                const url = endpoint + '/api/version/check?channel=' + encodeURIComponent(ch) + '&current=' + encodeURIComponent(current);
                const resp = await HttpUtil.request(url, { method: 'GET', timeout: 8000 });
                const text = await resp.text();
                const data = (function () { try { return JSON.parse(text); } catch (_) { return null; } })();
                if (data && data.code === 0 && data.data) {
                    const d = data.data;
                    // 相对路径（download_url/fallback_url）必须补后端 endpoint，否则 window.open/油猴会
                    // 拼到当前页域（weiban.mycourse.cn）→ 错误下载地址。full_download_url 为完整 URL 优先。
                    const _abs = (u) => {
                        if (!u) return '';
                        return /^https?:/.test(u) ? u : endpoint + u;
                    };
                    return {
                        needUpdate: !!d.update_required,
                        force: !!d.force_update,
                        latest: d.latest_version || '',
                        current: d.current_version || current,
                        channel: d.channel || ch,
                        changelog: d.changelog || '',
                        downloadUrl: _abs(d.full_download_url || d.download_url || ''),
                        fallbackUrl: _abs(d.fallback_url || ''),
                        fileSha256: d.file_sha256 || '',
                        fileSize: d.file_size || 0,
                        minClientVersion: d.min_client_version || '',
                        reason: d.reason || '',
                    };
                }
                throw new Error((data && data.message) || ('HTTP ' + resp.status));
            } catch (e) {
                if (e && e.name === 'AbortError') throw new Error('请求超时');
                throw e;
            }
        },

        // 启动期自动检查（fire-and-forget，网络失败静默，绝不阻塞主流程）。
        // force → 阻塞式 confirm 引导升级 + GM_setValue('forceUpdateRequired') 持久化；
        // 普通更新 → 右下角浮窗角标 + GM_setValue('pendingUpdate') 缓存；并同步面板版本状态。
        async autoCheck() {
            try {
                const result = await this.check(this.channel);
                try { GM_setValue('pendingUpdate', { latest: result.latest, changelog: result.changelog, url: result.downloadUrl, fallbackUrl: result.fallbackUrl, force: result.force, checkedAt: Date.now() }); } catch (_) {}
                if (result.force && result.needUpdate) {
                    try { GM_setValue('forceUpdateRequired', result.latest); } catch (_) {}
                    this.showBadge(result, true);
                    try {
                        const msg = [
                            '⚠️ 当前脚本版本过低，必须升级才能继续使用。',
                            '',
                            '最新版本：' + (result.latest || '未知'),
                            '更新内容：',
                            result.changelog || '（暂无说明）',
                            '',
                            '点击「确定」前往下载页完成升级。'
                        ].join('\n');
                        if (window.confirm(msg)) {
                            window.open(result.downloadUrl || result.fallbackUrl || '', '_blank');
                        }
                    } catch (_) {}
                } else if (result.needUpdate) {
                    this.showBadge(result, false);
                }
                // 同步面板"版本与更新"状态（面板已挂载时）
                try {
                    const ctl = window.shuakePanelInstance;
                    if (ctl && ctl._state && ctl._state.versionInfo) {
                        ctl._state.versionInfo.latest = result.latest;
                        ctl._state.versionInfo.needUpdate = result.needUpdate;
                        ctl._state.versionInfo.force = result.force;
                        ctl._state.versionInfo.changelog = result.changelog;
                        ctl._state.versionInfo.downloadUrl = result.downloadUrl;
                        ctl._state.versionInfo.fallbackUrl = result.fallbackUrl;
                        ctl._state.versionInfo.minClientVersion = result.minClientVersion;
                        ctl._state.versionInfo.channel = result.channel;
                        ctl._state.versionInfo.fileSha256 = result.fileSha256;
                        ctl._state.versionInfo.reason = result.reason;
                        ctl._state.versionInfo.lastCheck = new Date().toLocaleTimeString();
                    }
                } catch (_) {}
                try { Logger.info(result.force && result.needUpdate
                    ? `[版本] 检测到强制更新 ${result.latest}，当前 ${result.current} 版本过低必须升级`
                    : (result.needUpdate ? `[版本] 发现新版本 ${result.latest} 可更新` : '[版本] 已是最新版本')); } catch (_) {}
            } catch (e) {
                // 网络异常 / 服务端未就绪一律静默，绝不阻塞主流程
                try { Logger.debug('[版本] 启动期更新检查失败（静默）: ' + (e && e.message || '')); } catch (_) {}
            }
        },

        // 右下角浮窗角标（普通更新橙色 / 强制更新红色）
        showBadge(result, force) {
            try {
                let el = document.getElementById('__shuake_update_badge');
                if (!el) {
                    el = document.createElement('div');
                    el.id = '__shuake_update_badge';
                    el.style.cssText = 'position:fixed;right:12px;bottom:12px;z-index:1000001;padding:8px 14px;border-radius:14px;font-size:12px;cursor:pointer;box-shadow:0 2px 8px rgba(0,0,0,.25);font-family:-apple-system,BlinkMacSystemFont,"SF Pro Text","PingFang SC",sans-serif;user-select:none;display:none;';
                    el.addEventListener('click', () => {
                        try { window.open(result.downloadUrl || result.fallbackUrl || '', '_blank'); } catch (_) {}
                        try { el.style.display = 'none'; } catch (_) {}
                    });
                    document.body.appendChild(el);
                }
                el.style.display = 'inline-block';
                el.style.background = force ? '#ff3b30' : '#ff7a00';
                el.style.color = '#fff';
                el.textContent = force
                    ? ('⚠️ 必须升级：' + (result.latest || '') + ' → 点击下载')
                    : ('新版本 ' + (result.latest || '') + ' 可更新 →');
            } catch (_) {}
        }
    };

    // ========== 云端配置同步（pull / push / sync） ==========
    // AI API Key 默认不上传，由面板开关控制，避免用户私钥泄露到云端
    const CloudConfig = {
        ALLOWED_KEYS: [
            // 顶层业务开关
            'checkInterval', 'progressThreshold', 'injectDelay', 'pageTurnDelay',
            'triggerClickCooldown', 'maxRetryAttempts', 'enablePanel', 'autoNextCourse',
            'autoAdvanceEnabled', 'turboMode', 'turboModeDelay', 'canvasAutoBack',
            'waitForEstTimeout', 'minVideoPlayTime', 'realVideoPlay', 'videoPlaybackRate',
            'courseRepeatLimit', 'debugMode', 'logPersist', 'logMax', 'showDebugLogs',
            // AI 配置（不含 key，除非 includeKey=true）
            'aiConfig',
        ],
        SENSITIVE_KEYS: ['aiApiKey', 'apiKey'],

        // 序列化当前 CONFIG（过滤敏感字段 + 白名单）
        _serialize(includeKey) {
            const result = {};
            const cfg = { ...CONFIG };
            // 过滤面板 UI 状态字段（不应同步到云端）
            const skipKeys = ['panelVisible', 'minimized', 'activeTab', 'expanded', 'logSearch', 'logLevel', 'bankFilter'];
            for (const k of Object.keys(cfg)) {
                if (skipKeys.includes(k)) continue;
                if (!includeKey && this.SENSITIVE_KEYS.includes(k)) continue;
                if (k === 'aiConfig') {
                    // aiConfig 单独处理：去除 key
                    const ac = { ...(cfg.aiConfig || {}) };
                    if (!includeKey) delete ac.apiKey;
                    result.aiConfig = ac;
                    continue;
                }
                result[k] = cfg[k];
            }
            return result;
        },

        // 把 JSON blob 应用回 CONFIG + ConfigManager + PanelState
        _apply(blob, includeKey) {
            if (!blob || typeof blob !== 'object') return;
            const skipSensitive = !includeKey;
            for (const k of Object.keys(blob)) {
                if (skipSensitive && this.SENSITIVE_KEYS.includes(k)) continue;
                if (k === 'aiConfig') {
                    CONFIG.aiConfig = CONFIG.aiConfig || {};
                    for (const ak of Object.keys(blob.aiConfig || {})) {
                        if (skipSensitive && this.SENSITIVE_KEYS.includes(ak)) continue;
                        CONFIG.aiConfig[ak] = blob.aiConfig[ak];
                    }
                    continue;
                }
                CONFIG[k] = blob[k];
            }
            try { ConfigManager.save(); } catch (_) {}
            try {
                if (typeof PanelState !== 'undefined') {
                    PanelState.save(PanelState.load());
                }
            } catch (_) {}
        },

        // 上报本地配置到云端
        async push({ includeKey = false } = {}) {
            if (!CloudAuth.isLoggedIn()) {
                return { ok: false, error: '请先登录云端账户' };
            }
            const payload = this._serialize(includeKey);
            const size = new Blob([JSON.stringify(payload)]).size;
            if (size > 64 * 1024) {
                return { ok: false, error: `配置过大（${Math.round(size / 1024)}KB > 64KB）` };
            }
            try {
                const data = await CloudAuth._fetchJSON('/api/script/config', {
                    method: 'PUT',
                    body: JSON.stringify({ config: payload, include_key: includeKey }),
                });
                if (data && (data.code === 0 || data.ok)) {
                    try { Logger.success('配置已同步到云端'); } catch (_) {}
                    return { ok: true, version: data.data?.version };
                }
                return { ok: false, error: data?.message || '同步失败' };
            } catch (e) {
                return { ok: false, error: e?.message || '网络错误' };
            }
        },

        // 从云端拉取配置覆盖本地
        async pull({ includeKey = false } = {}) {
            if (!CloudAuth.isLoggedIn()) {
                return { ok: false, error: '请先登录云端账户' };
            }
            try {
                const data = await CloudAuth._fetchJSON('/api/script/config', { method: 'GET' });
                const cfg = (data && data.data && data.data.config) ? data.data.config : {};
                if (!cfg || Object.keys(cfg).length === 0) {
                    return { ok: false, error: '云端暂无配置' };
                }
                this._apply(cfg, includeKey);
                try { Logger.success('配置已从云端拉取并应用'); } catch (_) {}
                return { ok: true, version: data.data?.version };
            } catch (e) {
                return { ok: false, error: e?.message || '拉取失败' };
            }
        },

        // 先 pull 再 push（当前设备为主，冲突时以本地为准）
        async sync({ includeKey = false } = {}) {
            if (!CloudAuth.isLoggedIn()) {
                return { ok: false, error: '请先登录云端账户' };
            }
            // 1. 尝试 pull（忽略"云端暂无配置"错误）
            try {
                const data = await CloudAuth._fetchJSON('/api/script/config', { method: 'GET' });
                const cfg = (data && data.data && data.data.config) ? data.data.config : {};
                if (cfg && Object.keys(cfg).length > 0) {
                    this._apply(cfg, includeKey);
                    try { Logger.info('已从云端同步最新配置'); } catch (_) {}
                }
            } catch (_) {}
            // 2. push 本地配置
            return this.push({ includeKey });
        },
    };

    // ========== 云端题库客户端 ==========
    const CloudBank = {
        _healthy: false,
        _lastCheck: 0,
        _lastError: null,

        getConfig() {
            return (CONFIG && CONFIG.cloudBank) || {};
        },

        isEnabled() {
            const cfg = this.getConfig();
            return !!(cfg.enabled && cfg.endpoint);
        },

        _normalizeEndpoint(url) {
            if (!url) return '';
            return String(url).replace(/\/+$/, '');
        },

        _url(path) {
            const cfg = this.getConfig();
            const base = this._normalizeEndpoint(cfg.endpoint);
            return base + path;
        },

        async _fetchJSON(url, options = {}, timeoutMs = 5000) {
            try {
                // 认证优先级：① 用户配置的本系统 API Key（CONFIG.cloudBank.apiKey，Bearer 形式）
                // ② 云端账户 JWT（CloudAuth 登录态）③ 站点 x-token（DataBridge 兜底）
                // 背景：/api/bank/* 服务端 401 返回"请提供API Key或Bearer Token"，
                // 此前未带 API Key 导致批量上传失败 unknown。
                let token = null;
                try {
                    const cfgKey = (this.getConfig() && this.getConfig().apiKey) || '';
                    if (cfgKey) token = cfgKey;
                } catch (_) {}
                if (!token && typeof CloudAuth !== 'undefined' && CloudAuth.isLoggedIn()) {
                    token = CloudAuth.getToken();
                } else if (!token && typeof DataBridge !== 'undefined' && typeof DataBridge.getAuthToken === 'function') {
                    try { token = DataBridge.getAuthToken() || null; } catch (_) { token = null; }
                }
                const headers = Object.assign({
                    'Content-Type': 'application/json'
                }, (options.headers || {}));
                if (token) headers['Authorization'] = 'Bearer ' + token;
                // 【URL 拼接修复】CloudBank._fetchJSON 此前把传入 url 直接交给 HttpUtil.request，
                // 相对路径（如 '/api/study/report'）会打到当前站点（weiban.mycourse.cn）→ 404 → 上报失败 code=null。
                // 现与 CloudAuth._fetchJSON 一致：相对路径拼接 base endpoint；完整 URL 原样使用。
                const _cfg = this.getConfig();
                const _base = String(_cfg.endpoint || 'http://api.mk.heymeta.cn').replace(/\/+$/, '');
                const _fullUrl = (typeof url === 'string' && /^https?:/i.test(url)) ? url : (_base + url);
                // 优先 GM_xmlhttpRequest（绕过 https 页面发 http 的混合内容拦截 / CORS）
                const resp = await HttpUtil.request(_fullUrl, {
                    method: options.method || 'GET',
                    headers: headers,
                    body: options.body,
                    timeout: timeoutMs,
                });
                const text = await resp.text();
                // 诊断：记录最近一次响应 HTTP status + 响应体片段（404=接口未部署 / 401=认证失败 / 500=服务端异常 / 超时）
                try {
                    this._lastDiag = { url: _fullUrl, status: resp.status, body: String(text).substring(0, 300) };
                } catch (_) {}
                return SafeJSON.parse(text, null);
            } catch (e) {
                try {
                    this._lastDiag = Object.assign({ error: (e && e.message) || String(e) }, this._lastDiag || {});
                } catch (_) {}
                if (e?.name === 'AbortError') throw new Error('请求超时');
                throw e;
            }
        },

        async healthCheck() {
            const cfg = this.getConfig();
            if (!cfg.endpoint) {
                this._healthy = false;
                this._lastError = '未配置端点';
                return false;
            }
            try {
                const data = await this._fetchJSON(this._url('/health'), {}, 4000);
                // 后端 /health 返回 {status:"ok",...}（顶层）
                this._healthy = !!(data && (data.status === 'ok' || data.ok));
                this._lastCheck = Date.now();
                this._lastError = this._healthy ? null : '服务返回错误';
                return this._healthy;
            } catch (e) {
                this._healthy = false;
                this._lastCheck = Date.now();
                this._lastError = e?.message || String(e);
                return false;
            }
        },

        isHealthy() {
            return this._healthy;
        },

        getStatus() {
            return {
                healthy: this._healthy,
                lastCheck: this._lastCheck,
                lastError: this._lastError
            };
        },

        // 查询：官方题库优先（source=official 免费、游客可用每日限量），再社区题库；先 hash 精确，再前缀模糊
        // 后端官方接口：/api/bank/official/lookup（hash 精确）+ /api/bank/official/search（prefix 前缀）
        async lookup(question, options, qHash) {
            const cfg = this.getConfig();
            if (!this.isEnabled()) return null;
            const strategy = cfg.matchStrategy || 'both';
            const hash = qHash || (question && QuestionBank.computeHash(question, options));
            if (!hash) return null;
            // 前缀去开头数字序号（考试题干常带"1."，题库题目标题无序号），提升 prefix 命中率
            const cleanQuestion = String(question || '').replace(/^\s*\d+[.、．．\s]*/, '').trim();

            try {
                // 精确
                if (strategy === 'exact' || strategy === 'both') {
                    // ① 官方题库（免费优先）
                    const od = await this._fetchJSON(this._url(`/api/bank/official/lookup?hash=${encodeURIComponent(hash)}`), {}, 5000);
                    const odx = (od && od.data && typeof od.data === 'object') ? od.data : od;
                    if (odx && odx.hit && odx.record) {
                        try { Logger.info(`[题库] 官方题库精确命中[${odx.source || 'official'}]`); } catch (_) {}
                        return { source: 'official-exact', record: odx.record };
                    }
                    if (odx && odx.code === 40020) {
                        try { Logger.info(`游客官方题库每日限额已用完（100 次/天），注册账号不限量：${odx.message || '已达上限'}`); } catch (_) {}
                        this._lastError = odx.message || 'official daily limit';
                    }
                    // ② 社区/本地题库
                    const data = await this._fetchJSON(this._url(`/api/bank/lookup?hash=${encodeURIComponent(hash)}`), {}, 5000);
                    const d = (data && data.data && typeof data.data === 'object') ? data.data : data;
                    if (d && d.code === 40020) {
                        try { Logger.info(`游客官方题库每日限额已用完（100 次/天），注册账号不限量：${d.message || '已达上限'}`); } catch (_) {}
                        this._lastError = d.message || 'official daily limit';
                        return null;
                    }
                    if (d && d.hit && d.record) {
                        return { source: 'exact', record: d.record };
                    }
                }
                // 前缀
                if (strategy === 'prefix' || strategy === 'both') {
                    const prefix = cleanQuestion.slice(0, 60);
                    if (prefix.length >= 4) {
                        // ① 官方题库前缀
                        const od2 = await this._fetchJSON(this._url(`/api/bank/official/search?prefix=${encodeURIComponent(prefix)}&limit=5`), {}, 5000);
                        const odx2 = (od2 && od2.data && typeof od2.data === 'object') ? od2.data : od2;
                        if (odx2 && odx2.hit && Array.isArray(odx2.records) && odx2.records.length > 0) {
                            try { Logger.info(`[题库] 官方题库前缀命中[${odx2.source || 'official'}]`); } catch (_) {}
                            return { source: 'official-prefix', record: odx2.records[0] };
                        }
                        if (odx2 && odx2.code === 40020) {
                            try { Logger.info(`游客官方题库每日限额已用完（100 次/天），注册账号不限量：${odx2.message || '已达上限'}`); } catch (_) {}
                            this._lastError = odx2.message || 'official daily limit';
                        }
                        // ② 社区/本地题库前缀
                        const data = await this._fetchJSON(this._url(`/api/bank/search?prefix=${encodeURIComponent(prefix)}&limit=5`), {}, 5000);
                        const d = (data && data.data && typeof data.data === 'object') ? data.data : data;
                        if (d && d.code === 40020) {
                            try { Logger.info(`游客官方题库每日限额已用完（100 次/天），注册账号不限量：${d.message || '已达上限'}`); } catch (_) {}
                            this._lastError = d.message || 'official daily limit';
                            return null;
                        }
                        if (d && d.hit && Array.isArray(d.records) && d.records.length > 0) {
                            return { source: 'prefix', record: d.records[0] };
                        }
                    }
                }
            } catch (e) {
                try { Logger.debug(`CloudBank.lookup 失败: ${e?.message || e}`); } catch (_) {}
                this._lastError = e?.message || String(e);
            }
            return null;
        },

        async upload(record) {
            if (!this.isEnabled()) return { ok: false, error: 'disabled' };
            try {
                const data = await this._fetchJSON(this._url('/api/bank/upload'), {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ record })
                }, 8000);
                if (data === null || data === undefined) return { ok: false, error: '服务端无有效响应（端点不存在或返回非 JSON）' };
                const d = (data && data.data && typeof data.data === 'object') ? data.data : data;
                if (d && (d.ok === true || d.code === 0)) return { ok: true, id: d.id, merged: d.merged };
                const msg = (d && (d.error || d.message || d.msg))
                    || ('服务端返回异常（code=' + (d && d.code != null ? d.code : '?') + '）');
                return { ok: false, error: msg };
            } catch (e) {
                try { Logger.debug(`CloudBank.upload 失败: ${e?.message || e}`); } catch (_) {}
                return { ok: false, error: e?.message || String(e) };
            }
        },

        async batchUpload(records) {
            if (!this.isEnabled()) return { ok: false, error: 'disabled' };
            if (!Array.isArray(records) || records.length === 0) return { ok: false, error: 'empty' };
            try {
                const data = await this._fetchJSON(this._url('/api/bank/batch-upload'), {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ records })
                }, 12000);
                // 服务端无有效响应（端点不存在 / 返回非 JSON）→ 明确报错而非 unknown
                if (data === null || data === undefined) {
                    return { ok: false, error: '服务端无有效响应（端点不存在或返回非 JSON）' };
                }
                // 兼容两种返回：{ok:true,inserted,merged} 或 {code:0,data:{...}}
                const d = (data && data.data && typeof data.data === 'object') ? data.data : data;
                if (d && (d.ok === true || d.code === 0)) {
                    return { ok: true, inserted: d.inserted || 0, merged: d.merged || 0 };
                }
                // 服务端错误体（如 401 {code,message}）→ 提取 message 供面板可读
                const msg = (d && (d.error || d.message || d.msg))
                    || ('服务端返回异常（code=' + (d && d.code != null ? d.code : '?') + '）');
                return { ok: false, error: msg };
            } catch (e) {
                try { Logger.debug(`CloudBank.batchUpload 失败: ${e?.message || e}`); } catch (_) {}
                return { ok: false, error: e?.message || String(e) };
            }
        },

        async getStats() {
            if (!this.isEnabled()) return null;
            try {
                const data = await this._fetchJSON(this._url('/api/bank/stats'), {}, 4000);
                return (data && data.data && typeof data.data === 'object') ? data.data : data;
            } catch (e) {
                return null;
            }
        },

        // 官方题库：只在答题 query 时按需实时查询（需登录/游客登录），不下发全量到本地
    };

    const CloudAI = {
        // 是否可用：已登录云端账户 + 云端题库服务已启用
        isAvailable() {
            try {
                if (!(CloudAuth && CloudAuth.isLoggedIn())) return false;
                // 游客/自动注册账号：禁用充值 AI 答题（保留官方题库答题）
                if (typeof CloudAuth.isGuestAccount === 'function' && CloudAuth.isGuestAccount()) return false;
                return !!(CloudBank && CloudBank.isEnabled());
            } catch (_) { return false; }
        },

        // 云端 AI 答题：question + options -> {ok, answer, cost, balance, tokens, code?, error?}
        async query(question, options) {
            try {
                if (!question) return { ok: false, error: '题目为空' };
                if (!(CloudAuth && CloudAuth.isLoggedIn())) {
                    return { ok: false, code: 401, error: '未登录云端账户，请先在云端面板登录' };
                }
                // 游客/自动注册账号：禁用充值 AI 答题（保留官方题库答题）
                if (typeof CloudAuth.isGuestAccount === 'function' && CloudAuth.isGuestAccount()) {
                    return { ok: false, code: 403, error: '游客/自动注册账号不支持充值 AI 答题，请注册正式账号或使用官方题库答题' };
                }
                // 提交前清洗选项（去字体控件/UI 占位/伪选项/去重），保证 AI 记录与详情干净、AI 更准更省 token
                const cleanOptions = (typeof QuestionBank !== 'undefined' && typeof QuestionBank.cleanOptions === 'function')
                    ? QuestionBank.cleanOptions(options) : (Array.isArray(options) ? options : []);
                const data = await CloudAuth._fetchJSON('/api/ai/query', {
                    method: 'POST',
                    body: JSON.stringify({
                        question: String(question),
                        options: cleanOptions,
                    }),
                }, 30000);
                if (data && data.code === 0 && data.data && data.data.ok) {
                    const d = data.data;
                    const answer = String(d.answer || '').trim();
                    // 调用 /api/ai/query 成功 → 自动同步到题库（本地入库 + 上传云端题库，异步不阻塞 UI）
                    if (answer) this._syncToBank(question, options, answer);
                    return {
                        ok: true,
                        answer,
                        cost: d.cost,
                        balance: d.balance,
                        tokens: d.tokens,
                    };
                }
                return { ok: false, code: (data && data.code) || 0, error: (data && data.message) || '云端 AI 查询失败' };
            } catch (e) {
                return { ok: false, error: e?.message || '云端 AI 请求失败' };
            }
        },

        // 云端 AI 答题成功 → 自动同步到题库：本地 QuestionBank 入库 + 上传云端 CloudBank（异步不阻塞 UI）
        _syncToBank(question, options, answer) {
            try {
                if (!question || !answer) return;
                const QB = (typeof QuestionBank !== 'undefined') ? QuestionBank : null;
                if (!QB) return;
                const qHash = (typeof QB.generateQuestionHash === 'function')
                    ? QB.generateQuestionHash(question, options) : '';
                const record = (typeof QB.normalize === 'function')
                    ? QB.normalize({ qHash, question: String(question), options: Array.isArray(options) ? options : [], answer: String(answer), type: 'single', source: 'ai' })
                    : null;
                if (!record) return;
                Promise.resolve().then(async () => {
                    try {
                        // 1) 本地题库入库
                        if (typeof QB.upsert === 'function') QB.upsert(record);
                        // 2) 上传云端题库（云端 AI 答案无论 autoUpload 开关都沉淀回云端题库，形成闭环）
                        if (typeof CloudBank !== 'undefined' && CloudBank.isEnabled() && typeof CloudBank.upload === 'function') {
                            const res = await CloudBank.upload(record);
                            if (res && res.ok) {
                                try { Logger.debug(`云端 AI 已自动同步到题库: ${res.action || 'ok'}（${String(question).substring(0, 40)}...）`); } catch (_) {}
                            }
                        }
                    } catch (e) {
                        try { Logger.debug(`云端 AI 同步题库异常: ${e?.message || e}`); } catch (_) {}
                    }
                });
            } catch (_) {}
        },

        // 获取账户本系统访问 API Key 列表（/api/apikey/list，脱敏展示）
        async listAccountKeys() {
            try {
                if (!(CloudAuth && CloudAuth.isLoggedIn())) {
                    return { ok: false, code: 401, error: '未登录云端账户' };
                }
                const data = await CloudAuth._fetchJSON('/api/apikey/list?page=1&page_size=50', { method: 'GET' }, 10000);
                if (data && data.code === 0 && data.data) {
                    return { ok: true, keys: data.data.keys || [], total: data.data.total || 0 };
                }
                return { ok: false, error: (data && data.message) || '获取 Key 列表失败' };
            } catch (e) {
                return { ok: false, error: e?.message || '获取 Key 列表失败' };
            }
        },

        // 新建本系统访问 API Key（明文仅创建时返回一次）
        async createAccountKey(name) {
            try {
                if (!(CloudAuth && CloudAuth.isLoggedIn())) {
                    return { ok: false, code: 401, error: '未登录云端账户' };
                }
                const data = await CloudAuth._fetchJSON('/api/apikey/create', {
                    method: 'POST',
                    body: JSON.stringify({ name: String(name || '麦课刷课助手'), scope: 'all', quota: -1 }),
                }, 10000);
                if (data && data.code === 0 && data.data && data.data.api_key) {
                    return { ok: true, id: data.data.id, key: data.data.api_key, name: data.data.name || '' };
                }
                return { ok: false, error: (data && data.message) || '创建 API Key 失败' };
            } catch (e) {
                return { ok: false, error: e?.message || '创建 API Key 失败' };
            }
        },

        // 删除本系统访问 API Key
        async deleteAccountKey(id) {
            try {
                if (!(CloudAuth && CloudAuth.isLoggedIn())) {
                    return { ok: false, code: 401, error: '未登录云端账户' };
                }
                const data = await CloudAuth._fetchJSON('/api/apikey/' + encodeURIComponent(id), { method: 'DELETE' }, 10000);
                if (data && data.code === 0) {
                    return { ok: true };
                }
                return { ok: false, error: (data && data.message) || '删除 API Key 失败' };
            } catch (e) {
                return { ok: false, error: e?.message || '删除 API Key 失败' };
            }
        },

        // 测试云端 AI 连通性（会真实扣费一次，返回余额）
        async test() {
            try {
                if (!(CloudAuth && CloudAuth.isLoggedIn())) {
                    return { ok: false, code: 401, error: '未登录云端账户' };
                }
                return await this.query('测试题目：1+1=?', [
                    { order: 'A', content: '1' },
                    { order: 'B', content: '2' },
                    { order: 'C', content: '3' },
                ]);
            } catch (e) {
                return { ok: false, error: e?.message || '云端 AI 测试失败' };
            }
        },
    };

    // ========== DOM 安全工具 ==========
    const DOMUtils = {
        // 安全查询（document 可能是 null/跨域）
        query(doc, selector) {
            try {
                if (!doc || !doc.querySelector) return null;
                return doc.querySelector(selector);
            } catch (e) {
                return null;
            }
        },
        queryAll(doc, selector) {
            try {
                if (!doc || !doc.querySelectorAll) return [];
                return Array.from(doc.querySelectorAll(selector));
            } catch (e) {
                return [];
            }
        },
        // 检查元素是否在可视状态
        isVisible(el) {
            if (!el) return false;
            try {
                if (el.offsetParent === null) return false;
                const style = window.getComputedStyle(el);
                if (style.display === 'none' || style.visibility === 'hidden') return false;
                if (parseFloat(style.opacity) <= 0) return false;
                return true;
            } catch (e) {
                return false;
            }
        },
        // 安全获取文本
        getText(el) {
            if (!el) return '';
            try {
                return (el.textContent || '').trim();
            } catch (e) {
                return '';
            }
        },
        // 安全点击元素（仅触发原生 click 事件）
        safeClick(el) {
            if (!el) return false;
            try {
                if (typeof el.click === 'function') {
                    el.click();
                    return true;
                }
            } catch (e) {}
            return false;
        },
        /**
         * 模拟真实用户点按
         * 依次派发 PointerEvent + MouseEvent + （可选）TouchEvent + click，
         * 比单纯 el.click() 兼容性更好，能触发依赖 pointerdown/touchstart 的页面逻辑。
         *
         * @param {Element} el 目标元素
         * @param {Object} [opts]
         * @param {number} [opts.x]     事件 clientX，未提供则使用元素中心
         * @param {number} [opts.y]     事件 clientY，未提供则使用元素中心
         * @param {boolean} [opts.useTouch] 是否派发 touch 事件序列（移动端默认 true）
         * @param {boolean} [opts.bubbles=true]
         * @param {boolean} [opts.cancelable=true]
         * @returns {boolean} 是否派发成功
         */
        simulateClick(el, opts = {}) {
            if (!el || typeof el.dispatchEvent !== 'function') return false;
            const cfg = Object.assign({
                x: null, y: null,
                useTouch: false,
                bubbles: true,
                cancelable: true
            }, opts);
            let x = cfg.x, y = cfg.y;
            if (x == null || y == null) {
                try {
                    const rect = (typeof el.getBoundingClientRect === 'function')
                        ? el.getBoundingClientRect() : null;
                    if (rect && rect.width >= 0 && rect.height >= 0) {
                        x = Math.round(rect.left + rect.width / 2);
                        y = Math.round(rect.top + rect.height / 2);
                    } else {
                        x = y = 0;
                    }
                } catch (_) { x = y = 0; }
            }
            const common = {
                bubbles: cfg.bubbles, cancelable: cfg.cancelable,
                clientX: x, clientY: y,
                screenX: x, screenY: y,
                button: 0, buttons: 1,
                view: window
            };
            try {
                // 【关键】先触发原生 click()：浏览器视为受信事件（isTrusted=true）并授予 transient user activation，
                // 站点 JS 中依赖真实用户手势的处理器（如视频 play()、翻页回调）才会正常执行。
                // 之前先派发非受信事件再 click()，站点可能因首个事件 isTrusted=false 而拒绝执行。
                if (typeof el.click === 'function') {
                    try { el.click(); } catch (_) {}
                }
                if (cfg.useTouch && typeof TouchEvent !== 'undefined') {
                    try {
                        const t = new TouchEvent('touchstart', Object.assign({}, common, {
                            touches: [new Touch({ identifier: 0, target: el, clientX: x, clientY: y })],
                            targetTouches: [new Touch({ identifier: 0, target: el, clientX: x, clientY: y })],
                            changedTouches: [new Touch({ identifier: 0, target: el, clientX: x, clientY: y })]
                        }));
                        el.dispatchEvent(t);
                    } catch (_) {}
                }
                if (typeof PointerEvent !== 'undefined') {
                    try { el.dispatchEvent(new PointerEvent('pointerdown', Object.assign({ pointerType: 'mouse', isPrimary: true, pointerId: 1 }, common))); } catch (_) {}
                    try { el.dispatchEvent(new PointerEvent('pointerup',   Object.assign({ pointerType: 'mouse', isPrimary: true, pointerId: 1 }, common))); } catch (_) {}
                }
                try { el.dispatchEvent(new MouseEvent('mousedown', common)); } catch (_) {}
                try { el.dispatchEvent(new MouseEvent('mouseup',   common)); } catch (_) {}
                try { el.dispatchEvent(new MouseEvent('click',     common)); } catch (_) {}
                if (typeof el.onclick === 'function') {
                    try { el.onclick(); } catch (_) {}
                }
                return true;
            } catch (_) {
                return false;
            }
        }
    };

    // ========== DOM 智能监听器（基于 @violentmonkey/dom） ==========
    // 按选择器异步等待元素出现；支持一次性 / 永久监听 / 自动清理
    // 底层用 VM.observe（基于 MutationObserver），比 setInterval 轮询性能高得多
    const DOMWatcher = {
        // 内部注册表：disconnect 函数
        _watchers: new Set(),

        /**
         * 等待一个选择器首次匹配到元素；找到后自动停止监听
         * @param {string|Node} root 监听根节点（document/documentElement/body/具体元素）
         * @param {string} selector CSS 选择器
         * @param {(el: Element) => boolean|void} onFound 找到时回调；返回 true 立即停止
         * @param {object} [opts] 选项
         * @param {boolean} [opts.once=true] 是否只触发一次
         * @param {number} [opts.timeout=0] 超时（ms）；0 表示不超时
         * @returns {Function} 取消监听的函数
         */
        watch(root, selector, onFound, opts = {}) {
            if (!Libs.hasVMDom) {
                // 降级：使用 setInterval 轮询
                return this._fallbackPoll(root, selector, onFound, opts);
            }
            if (!root || typeof root !== 'object') {
                try { Logger.debug(`DOMWatcher.watch: 无效 root (${selector})`); } catch (_) {}
                return () => {};
            }
            const { once = true, timeout = 0 } = opts;
            const VM = Libs.VM;
            let triggered = false;
            let timer = null;
            const onHit = (el) => {
                if (triggered) return;
                try {
                    const result = onFound(el);
                    if (result === true || once) {
                        triggered = true;
                        try { stop(); } catch (_) {}
                    }
                } catch (e) {
                    try { Logger.debug(`DOMWatcher 回调异常: ${e.message}`); } catch (_) {}
                }
            };
            const stop = VM.observe(root, () => {
                try {
                    const el = root.querySelector ? root.querySelector(selector) : null;
                    if (el) {
                        onHit(el);
                        if (triggered) return true; // 解除监听
                    }
                } catch (_) {}
                return false;
            }, { childList: true, subtree: true });
            if (timeout > 0) {
                timer = setTimeout(() => {
                    try { stop(); } catch (_) {}
                }, timeout);
            }
            this._watchers.add(stop);
            return stop;
        },

        /**
         * 监听所有匹配选择器的元素（用于需要持续响应的场景，比如答题）
         * @param {string|Node} root
         * @param {string} selector
         * @param {(el: Element) => void} onFound 每个新元素触发一次
         * @returns {Function} cancel
         */
        watchAll(root, selector, onFound) {
            if (!Libs.hasVMDom || !root || typeof root !== 'object') {
                return () => {};
            }
            const seen = new WeakSet();
            const VM = Libs.VM;
            const stop = VM.observe(root, () => {
                try {
                    const nodes = root.querySelectorAll ? root.querySelectorAll(selector) : [];
                    for (const n of nodes) {
                        if (!seen.has(n)) {
                            seen.add(n);
                            try { onFound(n); } catch (e) {
                                try { Logger.debug(`DOMWatcher.watchAll 异常: ${e.message}`); } catch (_) {}
                            }
                        }
                    }
                } catch (_) {}
                return false;
            }, { childList: true, subtree: true });
            this._watchers.add(stop);
            return stop;
        },

        /**
         * 监听属性变化（基于 MutationObserver attributeFilter）
         * @param {Element} el
         * @param {string[]} attrs 要监听的属性列表
         * @param {(el: Element, attr: string) => void} onChange
         */
        watchAttributes(el, attrs, onChange) {
            if (!el || !Libs.hasVMDom) return () => {};
            const VM = Libs.VM;
            const stop = VM.observe(el, () => {
                try { onChange(el); } catch (_) {}
                return false;
            }, { attributes: true, attributeFilter: Array.isArray(attrs) ? attrs : [attrs] });
            this._watchers.add(stop);
            return stop;
        },

        /**
         * 等待并自动点击（高频操作：点击开始按钮、点击下一页等）
         * @param {string|Node} root
         * @param {string} selector
         * @param {number} maxRetries 失败最大重试次数
         * @returns {Promise<Element|null>}
         */
        async waitAndClick(root, selector, maxRetries = 0) {
            return new Promise((resolve) => {
                let attempts = 0;
                const tryClick = (el) => {
                    if (!el) return;
                    try {
                        if (el.offsetParent !== null && !el.disabled) {
                            try { el.click(); } catch (_) {}
                            resolve(el);
                            return;
                        }
                    } catch (_) {}
                    if (attempts < maxRetries) {
                        attempts++;
                        setTimeout(() => this.watch(root, selector, tryClick, { once: true }), 500);
                    } else {
                        resolve(null);
                    }
                };
                try {
                    const existing = root && root.querySelector ? root.querySelector(selector) : null;
                    if (existing) {
                        tryClick(existing);
                    } else {
                        this.watch(root, selector, tryClick, { once: true });
                    }
                } catch (e) {
                    resolve(null);
                }
            });
        },

        // 降级方案：setInterval 轮询
        _fallbackPoll(root, selector, onFound, opts) {
            const { once = true, timeout = 0, interval = 200 } = opts;
            let triggered = false;
            const start = Date.now();
            const timer = setInterval(() => {
                if (triggered) { clearInterval(timer); return; }
                if (timeout > 0 && Date.now() - start > timeout) { clearInterval(timer); return; }
                try {
                    const el = root && root.querySelector ? root.querySelector(selector) : null;
                    if (el) {
                        try { onFound(el); } catch (_) {}
                        if (once) { triggered = true; clearInterval(timer); }
                    }
                } catch (_) {}
            }, interval);
            this._watchers.add(() => clearInterval(timer));
            return () => clearInterval(timer);
        },

        /**
         * 清理所有 watch
         */
        disposeAll() {
            for (const stop of this._watchers) {
                try { stop(); } catch (_) {}
            }
            this._watchers.clear();
        }
    };

    // ========== 面板数据缓存（localStorage 持久化，跨页面/失败回退） ==========
    const DataCache = {
        PREFIX: 'shuake_data_v1_',
        TTL: {
            course: 6 * 3600 * 1000,      // 课程信息 6h
            project: 6 * 3600 * 1000,     // 项目进度 6h
            category: 12 * 3600 * 1000,   // 课程分类 12h
            exam: 12 * 3600 * 1000,       // 考试列表 12h
            bank: 30 * 24 * 3600 * 1000   // 题库快照 30d
        },
        _identity: null,
        identity() {
            if (this._identity) return this._identity;
            const params = new URLSearchParams(window.location.search);
            const hash = window.location.hash;
            let up = '', uid = '', tc = '';
            try {
                if (hash && hash.includes('userProjectId=')) {
                    const hp = new URLSearchParams(hash.split('?')[1] || '');
                    up = hp.get('userProjectId') || '';
                    uid = hp.get('userId') || '';
                    tc = hp.get('tenantCode') || '';
                }
                if (!up) up = params.get('userProjectId') || '';
                if (!uid) uid = params.get('userId') || '';
                if (!tc) tc = params.get('tenantCode') || '';
            } catch (_) {}
            const base = (up || uid || tc || '');
            // 无身份参数时按 hostname 隔离，避免同域不同项目/用户缓存互相覆盖
            const dim = (base || (window.location.hostname || 'anon'));
            let h = 0;
            for (let i = 0; i < dim.length; i++) { const c = dim.charCodeAt(i); h = ((h << 5) - h) + c; h = h & h; }
            this._identity = h.toString(36);
            return this._identity;
        },
        key(type) { return this.PREFIX + type + '_' + this.identity(); },
        save(type, value) {
            try {
                if (value == null) return false;
                localStorage.setItem(this.key(type), JSON.stringify({ t: Date.now(), v: value }));
                return true;
            } catch (_) { return false; }
        },
        load(type) {
            try {
                const raw = localStorage.getItem(this.key(type));
                if (!raw) return null;
                const obj = SafeJSON.parse(raw, null);
                if (!obj || typeof obj !== 'object' || obj.t == null || obj.v == null) return null;
                const ttl = this.TTL[type] || 12 * 3600 * 1000;
                if (Date.now() - obj.t > ttl) { try { localStorage.removeItem(this.key(type)); } catch (_) {} return null; }
                return obj.v;
            } catch (_) { return null; }
        }
    };

    // ========== 跨子域数据桥（.mycourse.cn 各子域 localStorage 无法共享，用 postMessage 互通） ==========
    // weiban.mycourse.cn / mcwk.mycourse.cn 是不同的 origin，localStorage 各自独立。
    // 列表页（如 weiban）拉到的分类/考试/题库在课程页（如 mcwk）读不到，通过隐藏 iframe + postMessage 互通。
    const DataBridge = {
        HOSTS: ['weiban.mycourse.cn', 'mcwk.mycourse.cn'],
        _listenerRegistered: false,
        // 收集当前 origin 可共享的快照（题库 + 面板数据缓存 + 登录态 user）
        _snapshot() {
            const snap = { __sk_bridge_resp: true, bank: null, category: null, exam: null, project: null, course: null, user: null };
            try {
                const raw = localStorage.getItem(QuestionBank.STORAGE_KEY);
                const records = raw ? SafeJSON.parse(raw, []) : [];
                if (Array.isArray(records) && records.length > 0) snap.bank = records.slice(0, 2000);
            } catch (_) {}
            for (const t of ['category', 'exam', 'project', 'course']) {
                try { snap[t] = DataCache.load(t); } catch (_) {}
            }
            // 登录态：weiban 域 localStorage['user'] 是权威（含 token/jwtToken/tenantCode/userId），桥接给 mcwk 学习页
            try {
                const userRaw = localStorage.getItem('user');
                if (userRaw) {
                    const u = SafeJSON.parse(userRaw, null);
                    if (u && typeof u === 'object' && (u.token || u.jwtToken)) snap.user = u;
                }
            } catch (_) {}
            return snap;
        },
        // 注册被动监听：收到数据请求时，把当前 origin 的快照回复过去（幂等）
        registerListener() {
            try {
                if (this._listenerRegistered) return;
                this._listenerRegistered = true;
                window.addEventListener('message', (e) => {
                    try {
                        if (!e.data || typeof e.data !== 'object' || e.data.__sk_bridge_req !== true) return;
                        const snap = this._snapshot();
                        if (e.source && typeof e.source.postMessage === 'function') {
                            e.source.postMessage(snap, '*');
                        }
                    } catch (_) {}
                });
            } catch (_) {}
        },
        // 兼容旧名（题库桥）
        registerBankListener() { this.registerListener(); },

        // ======== 供外部调用的便捷方法（从桥接/本地身份中取 token 与 user） ========
        // 历史上很多调用方写 `DataBridge.getAuthToken()`：CloudBank._fetchJSON 就是其一。
        // 按优先级返回可用于"第三方云端 JWT + 站点 x-token"的 token：
        //   1) 若 CloudAuth (云端账号) 已登录，返回 CloudAuth JWT（供 Authorization: Bearer）
        //   2) 否则尝试用"窃听/本地身份"拿到的站点 x-token（供 Authorization 或 x-token 头）
        getAuthToken() {
            try {
                // A. 云端账号 JWT（真正意义上的"跨端统一鉴权 token"）
                if (typeof CloudAuth !== 'undefined' && typeof CloudAuth.getToken === 'function' && CloudAuth.isLoggedIn()) {
                    try {
                        const t = CloudAuth.getToken();
                        if (t) return t;
                    } catch (_) {}
                }
                // B. 站点侧 x-token（ajax-hook 窃听优先，再退到 localStorage / cookie）
                try {
                    if (typeof AjaxHooker !== 'undefined' && typeof AjaxHooker.getToken === 'function') {
                        const tk = AjaxHooker.getToken('x-token');
                        if (tk) return tk;
                    }
                } catch (_) {}
                try { const s = readStoredToken(); if (s) return s; } catch (_) {}
                try { if (window.__authToken) return window.__authToken; } catch (_) {}
                try {
                    const u = this.getUser();
                    if (u && typeof u === 'object') {
                        if (u.token) return u.token;
                        if (u.jwtToken) return u.jwtToken;
                    }
                } catch (_) {}
                return null;
            } catch (_) { return null; }
        },
        // 取当前 weiban 身份 user 对象（来自 localStorage.user 或 DataBridge.syncFromSiblings 的桥接缓存）
        getUser() {
            try {
                if (typeof Identity !== 'undefined' && Identity.data) {
                    const d = Identity.data;
                    if (d && typeof d === 'object' && (d.token || d.userId)) return d;
                }
                try {
                    const raw = localStorage.getItem('user');
                    if (raw) {
                        const u = SafeJSON.parse(raw, null);
                        if (u && typeof u === 'object') return u;
                    }
                } catch (_) {}
                // 应用兄弟子域桥接缓存（如果之前 syncFromSiblings 拿到过）
                try {
                    const raw2 = DataCache.load('__bridge_user');
                    if (raw2 && typeof raw2 === 'object') return raw2;
                } catch (_) {}
                return null;
            } catch (_) { return null; }
        },
        // 仅取站点侧 x-token（getAuthToken 会优先拿云端 JWT，调用方需要区分时用这个）
        getSiteToken() {
            try {
                try {
                    if (typeof AjaxHooker !== 'undefined' && typeof AjaxHooker.getToken === 'function') {
                        const x = AjaxHooker.getToken('x-token');
                        if (x) return x;
                    }
                } catch (_) {}
                try { const s = readStoredToken(); if (s) return s; } catch (_) {}
                try { if (window.__authToken) return window.__authToken; } catch (_) {}
                try {
                    const u = this.getUser();
                    if (u && typeof u === 'object') return (u.token || u.jwtToken || null);
                } catch (_) {}
                return null;
            } catch (_) { return null; }
        },

        // 尝试从兄弟子域拉取快照（隐藏 iframe，超时兜底，被 X-Frame-Options 拦截则静默失败）
        requestData(timeoutMs = 5000) {
            return new Promise((resolve) => {
                let done = false;
                const finish = (val) => { if (!done) { done = true; try { clearTimeout(timer); } catch (_) {} cleanup(); resolve(val); } };
                const currentHost = (window.location.hostname || '').toLowerCase();
                const targets = this.HOSTS.filter(h => h !== currentHost);
                if (targets.length === 0) { finish(null); return; }
                const timer = setTimeout(() => finish(null), timeoutMs);
                const handler = (e) => {
                    try {
                        if (!e.data || typeof e.data !== 'object' || e.data.__sk_bridge_resp !== true) return;
                        finish(e.data);
                    } catch (_) {}
                };
                window.addEventListener('message', handler);
                const iframes = [];
                const cleanup = () => {
                    try { window.removeEventListener('message', handler); } catch (_) {}
                    for (const f of iframes) { try { if (f && f.parentNode) f.parentNode.removeChild(f); } catch (_) {} }
                };
                for (const host of targets) {
                    try {
                        const iframe = document.createElement('iframe');
                        iframe.style.cssText = 'display:none;width:0;height:0;border:0;position:absolute;left:-9999px;top:-9999px;';
                        iframe.setAttribute('aria-hidden', 'true');
                        iframe.src = 'https://' + host + '/';
                        iframe.onload = () => {
                            try {
                                if (iframe.contentWindow && typeof iframe.contentWindow.postMessage === 'function') {
                                    iframe.contentWindow.postMessage({ __sk_bridge_req: true, nonce: Date.now() }, 'https://' + host + '/');
                                }
                            } catch (_) {}
                        };
                        iframe.onerror = () => {};
                        (document.body || document.documentElement).appendChild(iframe);
                        iframes.push(iframe);
                    } catch (_) {}
                }
            });
        },
        // 兼容旧名：拉取题库
        requestBank(timeoutMs) { return this.requestData(timeoutMs).then((d) => (d && Array.isArray(d.bank) ? d.bank : null)); },
        // 将桥接到的快照应用到模块 + 缓存（bank 由 QuestionBank 处理）
        applySnapshot(snap) {
            if (!snap || typeof snap !== 'object') return false;
            let applied = false;
            try {
                if (Array.isArray(snap.category) && snap.category.length > 0) {
                    try { CategoryInfo.data = normalizeCategories(snap.category); }
                    catch (_) { CategoryInfo.data = snap.category; }
                    DataCache.save('category', CategoryInfo.data);
                    applied = true;
                }
            } catch (_) {}
            try {
                if (Array.isArray(snap.exam) && snap.exam.length > 0) {
                    ExamManager.data = snap.exam;
                    DataCache.save('exam', snap.exam);
                    applied = true;
                }
            } catch (_) {}
            try {
                if (snap.project && typeof snap.project === 'object') {
                    ProjectInfo.data = snap.project;
                    DataCache.save('project', snap.project);
                    applied = true;
                }
            } catch (_) {}
            try {
                if (snap.course && typeof snap.course === 'object') {
                    if (!CourseInfo.data) CourseInfo.data = snap.course;
                    DataCache.save('course', snap.course);
                    applied = true;
                }
            } catch (_) {}
            // 登录态：把兄弟域（weiban）的 user 登录信息落到本地，供 readStoredToken()/身份解析使用
            try {
                if (snap.user && typeof snap.user === 'object' && (snap.user.token || snap.user.jwtToken)) {
                    const cur = readStoredUser();
                    // 仅当本地没有更权威的 user 时才覆盖（避免覆盖本域真实登录态）
                    if (!cur || (!cur.token && !cur.jwtToken)) {
                        try {
                            localStorage.setItem('shuake_bridged_user', JSON.stringify(snap.user));
                            // 同步到 DataCache（DataBridge.getUser 不用 localStorage 也能拿到）
                            try { DataCache.save('__bridge_user', snap.user); } catch (_) {}
                            if (snap.user.token) window.__authToken = String(snap.user.token);
                            Logger.info(`跨域桥: 已桥接登录态 (tenantCode=${snap.user.tenantCode || ''})`);
                            applied = true;
                        } catch (_) {}
                    }
                }
            } catch (_) {}
            return applied;
        },
        // 完整流程：请求 → 应用 → 返回是否有数据
        async syncFromSiblings(timeoutMs = 5000) {
            try {
                const snap = await this.requestData(timeoutMs);
                if (!snap) return false;
                let applied = this.applySnapshot(snap);
                // 题库单独处理（走 QuestionBank 合并去重）
                if (Array.isArray(snap.bank) && snap.bank.length > 0) {
                    try {
                        const norm = snap.bank.map((r) => QuestionBank.normalize(r)).filter(Boolean);
                        if (norm.length > 0) {
                            const existing = QuestionBank._safeReadArray(QuestionBank.STORAGE_KEY);
                            const merged = QuestionBank._mergeRecords(existing, norm);
                            QuestionBank._writeAll(merged);
                            QuestionBank._records = QuestionBank._safeReadArray(QuestionBank.STORAGE_KEY);
                            applied = true;
                        }
                    } catch (_) {}
                }
                return applied;
            } catch (_) { return false; }
        }
    };

    // ========== 从浏览器本地存储读取认证信息 ==========
    // 站点把用户信息（含 token/jwtToken/tenantCode/userId）存在 localStorage['user']（JSON），
    // 学习页 iframe / weiban SPA hash 路由常缺 tenantCode/userId，必须从这里兜底。
    function readStoredUser() {
        try {
            const userRaw = localStorage.getItem('user');
            if (userRaw) {
                const userObj = SafeJSON.parse(userRaw, null);
                if (userObj && typeof userObj === 'object' && (userObj.token || userObj.jwtToken || userObj.tenantCode || userObj.userId)) return userObj;
            }
        } catch (_) {}
        // 兜底：跨域桥接的登录态（weiban → mcwk）
        try {
            const bridged = localStorage.getItem('shuake_bridged_user');
            if (bridged) {
                const userObj = SafeJSON.parse(bridged, null);
                if (userObj && typeof userObj === 'object') return userObj;
            }
        } catch (_) {}
        return null;
    }

    // 从 localStorage['user'] 读取认证 token（优先 uuid token，其次 jwtToken）
    function readStoredToken() {
        try {
            const userObj = readStoredUser();
            if (userObj) {
                // 优先用窃听/桥接刷新的 token（比 localStorage['user'] 更新鲜）
                try {
                    const bridgedRaw = localStorage.getItem('shuake_bridged_user');
                    if (bridgedRaw) {
                        const b = SafeJSON.parse(bridgedRaw, null);
                        if (b) {
                            if (b.token) return String(b.token);
                            if (b.jwtToken) return String(b.jwtToken);
                        }
                    }
                } catch (_) {}
                if (userObj.token) return String(userObj.token);
                if (userObj.jwtToken) return String(userObj.jwtToken);
            }
        } catch (_) {}
        // 直接键（x-token / token / access_token）
        for (const k of ['x-token', 'token', 'access_token', 'auth-token']) {
            try {
                const v = localStorage.getItem(k);
                if (v) return String(v);
            } catch (_) {}
        }
        return null;
    }

    // 用 localStorage['user'] / 脚本持久化身份 / projectId 别名 补齐 URL 缺失的身份字段
    // （用户诉求：在别的页面持久化保存配置和参数，跨页复用 userProjectId/userId/tenantCode 等）
    const StoredIdentity = {
        KEY: 'shuake_identity',
        load() {
            try {
                const raw = localStorage.getItem(this.KEY);
                if (!raw) return null;
                const o = SafeJSON.parse(raw, null);
                return (o && typeof o === 'object') ? o : null;
            } catch (_) { return null; }
        },
        save() {
            try {
                const params = new URLSearchParams(window.location.search);
                let hashPart = window.location.hash;
                if (hashPart.startsWith('#')) hashPart = hashPart.slice(1);
                const hp = hashPart.includes('=') ? new URLSearchParams(hashPart.split('?')[1] || hashPart) : null;
                const get = (k) => {
                    let v = params.get(k);
                    if (!v && hp) v = hp.get(k);
                    return v || '';
                };
                const cur = this.load() || {};
                const merged = {
                    userProjectId: cur.userProjectId || '',
                    userId: cur.userId || '',
                    tenantCode: cur.tenantCode || '',
                    courseId: cur.courseId || '',
                    userCourseId: cur.userCourseId || ''
                };
                // 仅用非空新值覆盖，避免空参数冲掉已保存的有效值
                const v = get('userProjectId') || get('projectId'); if (v) merged.userProjectId = v;
                if (get('userId')) merged.userId = get('userId');
                if (get('tenantCode')) merged.tenantCode = get('tenantCode');
                if (get('courseId')) merged.courseId = get('courseId');
                if (get('userCourseId')) merged.userCourseId = get('userCourseId');
                localStorage.setItem(this.KEY, JSON.stringify(merged));
            } catch (_) {}
        }
    };

    function fillStoredIdentity(obj) {
        try {
            const u = readStoredUser();
            if (u) {
                if (!obj.tenantCode && u.tenantCode) obj.tenantCode = String(u.tenantCode);
                if (!obj.userId && u.userId) obj.userId = String(u.userId);
                if (!obj.userProjectId && u.userProjectId) obj.userProjectId = String(u.userProjectId);
            }
        } catch (_) {}
        // 脚本持久化身份（跨页复用）
        try {
            const si = StoredIdentity.load();
            if (si) {
                if (!obj.userProjectId && si.userProjectId) obj.userProjectId = String(si.userProjectId);
                if (!obj.tenantCode && si.tenantCode) obj.tenantCode = String(si.tenantCode);
                if (!obj.userId && si.userId) obj.userId = String(si.userId);
            }
        } catch (_) {}
        // projectId 别名 → userProjectId（列表页 #/course?projectId=...）
        if (!obj.userProjectId) {
            try {
                let pid = null;
                const params = new URLSearchParams(window.location.search);
                pid = params.get('projectId');
                if (!pid) {
                    let hashPart = window.location.hash;
                    if (hashPart.startsWith('#')) hashPart = hashPart.slice(1);
                    if (hashPart.includes('projectId=')) {
                        try { pid = new URLSearchParams(hashPart.split('?')[1] || hashPart).get('projectId'); } catch (_) {}
                    }
                }
                if (pid) obj.userProjectId = String(pid);
            } catch (_) {}
        }
        // 从持久化身份再兜底一次（含 projectId 曾保存为 userProjectId 的情形）
        if (!obj.userProjectId) {
            try {
                const si = StoredIdentity.load();
                if (si && si.userProjectId) obj.userProjectId = String(si.userProjectId);
            } catch (_) {}
        }
    }

    // ========== 课程信息获取 ==========
    const CourseInfo = {
        data: null,
        userCourseId: null,
        courseId: null,
        projectId: null,

        parseURL() {
            // 先尝试从 hash 中解析参数
            const hash = window.location.hash;
            if (hash && hash.includes('courseId=')) {
                const hashParams = new URLSearchParams(hash.split('?')[1] || '');
                this.userCourseId = hashParams.get('userCourseId');
                this.courseId = hashParams.get('courseId');
                this.projectId = hashParams.get('userProjectId');
                Logger.debug(`从 hash 解析: userCourseId=${this.userCourseId}, courseId=${this.courseId}`);
            } else {
                const params = new URLSearchParams(window.location.search);
                this.userCourseId = params.get('userCourseId');
                this.courseId = params.get('courseId');
                this.projectId = params.get('userProjectId');
            }
            // 补齐 URL 缺失的身份字段（localStorage['user'] / 持久化身份 / projectId 别名）
            try { fillStoredIdentity(this); } catch (_) {}
            // 统一 userProjectId 字段（body 用 this.projectId 兼容）
            if (!this.projectId && this.userProjectId) this.projectId = this.userProjectId;
            if (!this.userProjectId && this.projectId) this.userProjectId = this.projectId;
        },

        async fetchDetails() {
            this.parseURL();
            if (!this.userCourseId || !this.courseId) {
                Logger.debug('URL 中无课程ID参数，从页面获取');
                return this.getFromDOM();
            }

            // 首先从 DOM 获取课程信息（最可靠）
            const domInfo = this.getFromDOM();
            if (domInfo) {
                DataCache.save('course', this.data);
                return domInfo;
            }

            // DOM 获取失败时尝试 API（添加认证头）
            const authToken = this.getAuthToken();
            if (!authToken) {
                Logger.debug('未获取到认证 token');
                const cached = DataCache.load('course');
                if (cached && typeof cached === 'object') {
                    this.data = cached;
                    Logger.debug('课程信息：使用本地缓存');
                    return cached;
                }
                return null;
            }

            try {
                // 尝试使用 pharos API
                const api = `https://weiban.mycourse.cn/pharos/usercourse/getCourse.do`;
                const resp = await AjaxHooker.apiFetch(api, {
                    method: 'POST',
                    credentials: 'include',
                    headers: {
                        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                        'x-token': authToken,
                        'Accept': 'application/json'
                    },
                    body: `userCourseId=${this.userCourseId}&courseId=${this.courseId}&tenantCode=${this.tenantCode || ''}&userId=${this.userId || ''}&userProjectId=${this.projectId || ''}`
                });

                if (resp.ok) {
                    const result = await resp.json();
                    if (result.code === '0' && result.data) {
                        this.data = result.data;
                        DataCache.save('course', this.data);
                        Logger.info(`API 获取成功: ${this.data.name || this.data.courseName}`);
                        return this.data;
                    }
                }
            } catch (e) {
                Logger.debug(`API 获取失败: ${e.message}`);
            }

            const cached = DataCache.load('course');
            if (cached && typeof cached === 'object') {
                this.data = cached;
                Logger.debug('课程信息：API 失败，使用本地缓存');
                return cached;
            }

            // 兜底：通过 listCourse.do 接口按 courseId / userCourseId 匹配课程名（参考 HAR 接口数据）
            try {
                const token = this.getAuthToken();
                if (token && typeof StudyAssistant !== 'undefined' && typeof StudyAssistant.fetchCourses === 'function') {
                    const list = await StudyAssistant.fetchCourses();
                    if (Array.isArray(list) && list.length > 0) {
                        const match = list.find((c) =>
                            (c.resourceId && this.courseId && c.resourceId === this.courseId) ||
                            (c.userCourseId && this.userCourseId && c.userCourseId === this.userCourseId)
                        );
                        if (match && match.resourceName) {
                            const base = (this.data && typeof this.data === 'object') ? this.data : {};
                            this.data = {
                                name: match.resourceName,
                                courseName: match.resourceName,
                                totalTime: base.totalTime || base.courseTime || '未知',
                                totalPage: base.totalPage || '未知',
                                finishedPage: base.finishedPage || 0,
                                progress: base.progress || 0
                            };
                            State.currentCourseName = match.resourceName;
                            DataCache.save('course', this.data);
                            Logger.info(`[接口] 课程名匹配成功: ${match.resourceName}`);
                            return this.data;
                        }
                    }
                }
            } catch (e) {
                Logger.debug(`listCourse 课程名匹配失败: ${e.message}`);
            }

            return null;
        },

        // 获取认证 token
        getAuthToken() {
            // 0) 优先 ajax-hook 捕获的站点真实 x-token（站点自身 XHR 所用，干净无自我污染）
            const captured = AjaxHooker.getToken('x-token');
            if (captured) return captured;
            // 1) localStorage['user'] 会话 token 兜底
            const storedFirst = readStoredToken();
            if (storedFirst) return storedFirst;
            // 2) 之前注入的全局变量
            if (window.__authToken) {
                return window.__authToken;
            }
            // 3) 从 cookie 中解析（兜底）
            try {
                const cookies = document.cookie.split(';');
                for (const cookie of cookies) {
                    const [name, value] = cookie.trim().split('=');
                    if (name === 'x-token' || name === 'token') {
                        return value;
                    }
                }
            } catch (e) {}
            return null;
        },

        getFromDOM() {
            try {
                // 排除验证码页面（CAPTCHA/验证类提示）
                const captchaPatterns = ['验证', 'captcha', '拼图', '滑动', '拖动', '安全', '验证中'];
                const isCaptchaPage = () => {
                    try {
                        const body = document.body?.textContent || '';
                        return captchaPatterns.some(p => body.includes(p));
                    } catch (e) {
                        return false;
                    }
                };

                // 获取标题元素
                let nameEl = DOMUtils.query(document, '.course-name, .course-title, [class*="course-name"], [class*="courseTitle"]');
                if (!nameEl) {
                    nameEl = DOMUtils.query(document, 'h1, h2');
                }

                const name = DOMUtils.getText(nameEl);

                // 验证名称是否有效（不是验证码提示）
                if (name && !isCaptchaPage()) {
                    this.data = { name, courseName: name };
                    State.currentCourseName = name;
                    Logger.info(`从 DOM 获取课程名: ${name}`);
                    return this.data;
                }
            } catch (e) {
                Logger.debug(`getFromDOM 异常: ${e.message}`);
            }
            return null;
        },

        getDisplayInfo() {
            if (this.data) {
                return {
                    name: this.data.name || this.data.courseName || '未知课程',
                    totalTime: this.data.totalTime || this.data.courseTime || '未知',
                    totalPage: this.data.totalPage || '未知',
                    finishedPage: this.data.finishedPage || 0,
                    progress: this.data.progress || 0
                };
            }
            return {
                name: State.currentCourseName || '未知课程',
                totalTime: '未知',
                totalPage: '未知',
                finishedPage: 0,
                progress: 0
            };
        }
    };

    // ========== 项目进度信息获取 ==========
    const ProjectInfo = {
        data: null,
        tenantCode: null,
        userProjectId: null,

        parseURL() {
            const params = new URLSearchParams(window.location.search);
            const hash = window.location.hash;
            
            // 优先从 hash 获取
            if (hash && hash.includes('userProjectId=')) {
                const hashParams = new URLSearchParams(hash.split('?')[1] || '');
                this.userProjectId = hashParams.get('userProjectId');
                this.tenantCode = hashParams.get('tenantCode');
            } else {
                this.userProjectId = params.get('userProjectId');
                this.tenantCode = params.get('tenantCode');
            }
            // URL 缺 tenantCode/userId 时从 localStorage['user'] 补齐
            fillStoredIdentity(this);
            Logger.debug(`ProjectInfo 解析: userProjectId=${this.userProjectId}, tenantCode=${this.tenantCode}`);
        },

        // 获取认证 token
        getAuthHeaders() {
            // 0) 优先 ajax-hook 捕获的站点真实 x-token，其次 localStorage 会话 token
            try { const captured = AjaxHooker.getToken('x-token'); if (captured) return captured; } catch (_) {}
            try { const storedFirst = readStoredToken(); if (storedFirst) return storedFirst; } catch (_) {}
            // 1) 尝试从 iframe 中获取 token
            try {
                const iframe = document.querySelector('iframe.page-iframe, iframe[class*="iframe"]');
                if (iframe && iframe.contentWindow) {
                    const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
                    // 从 iframe 的 fetch/xhr 中获取 token，或者从 meta 标签
                    const metaToken = iframeDoc.querySelector('meta[name="x-token"]');
                    if (metaToken) {
                        return metaToken.content;
                    }
                }
            } catch (e) {
                Logger.debug(`获取 iframe token 失败: ${e.message}`);
            }
            
            // 尝试从当前页面的 fetch 拦截中获取
            if (window.__authToken) {
                return window.__authToken;
            }
            
            // 尝试从 cookie 中解析（备选方案）
            const cookies = document.cookie.split(';');
            for (const cookie of cookies) {
                const [name, value] = cookie.trim().split('=');
                if (name === 'x-token' || name === 'token' || name === 'access_token') {
                    return value;
                }
            }
            
            return null;
        },

        async fetchDetails() {
            this.parseURL();
            if (!this.userProjectId) {
                Logger.debug('URL 中无 userProjectId 参数');
                return null;
            }

            const authHeaders = this.getAuthHeaders();
            if (!authHeaders) {
                Logger.debug('未获取到认证 token，跳过项目进度获取');
                const cached = DataCache.load('project');
                if (cached && typeof cached === 'object') {
                    this.data = cached;
                    Logger.debug('项目进度：使用本地缓存');
                    return cached;
                }
                return null;
            }

            try {
                const url = `https://weiban.mycourse.cn/pharos/project/showProgress.do`;
                const resp = await AjaxHooker.apiFetch(url, {
                    method: 'POST',
                    credentials: 'include',
                    headers: Object.assign({}, AjaxHooker.getSiteHeaders(), {
                        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                        'x-token': authHeaders,
                        'Accept': 'application/json'
                    }),
                    body: `userProjectId=${this.userProjectId}&tenantCode=${this.tenantCode || ''}&userId=${this.userId || ''}&chooseType=3`
                });

                if (resp.ok) {
                    const result = await resp.json();
                    if (result.code === '0' && result.data) {
                        this.data = result.data;
                        DataCache.save('project', this.data);
                        Logger.info(`项目信息获取成功: ${this.data.name}`);
                        return this.data;
                    } else {
                        Logger.debug(`项目信息 API 返回异常: ${JSON.stringify(result)}`);
                    }
                } else {
                    Logger.debug(`项目信息请求失败: ${resp.status} ${resp.statusText}${(resp.status===401||resp.status===463) ? '（token 无效或跨域网关拦截，将依赖兄弟域缓存/桥接）' : ''}`);
                }
            } catch (e) {
                Logger.debug(`获取项目信息失败: ${e.message}`);
            }
            const cached = DataCache.load('project');
            if (cached && typeof cached === 'object') {
                this.data = cached;
                Logger.debug('项目进度：API 失败，使用本地缓存');
                return cached;
            }
            return null;
        },

        getDisplayInfo() {
            if (!this.data) return null;
            return {
                name: this.data.name || '未知项目',
                studyStateLabel: this.data.studyStateLabel || '未知',
                requiredNum: this.data.requiredNum || 0,
                requiredFinishedNum: this.data.requiredFinishedNum || 0,
                examNum: this.data.examNum || 0,
                examFinishedNum: this.data.examFinishedNum || 0,
                examAssessmentNum: this.data.examAssessmentNum || 0,
                endTime: this.data.endTime || '未知',
                lastDays: this.data.lastDays || 0,
                progressPet: this.data.progressPet || 0,
                assessment: this.data.assessment || '',
                assessmentRemark: this.data.assessmentRemark || ''
            };
        }
    };

    // ========== 课程分类信息获取 ==========
    // 归一化 listCategory 接口返回的分类：补齐 totalNum/requiredNum/pendingNum/progressPet/status
    // 接口原始字段：categoryCode/categoryName/categoryRemark/totalNum/finishedNum/categoryImageUrl
    function normalizeCategories(list) {
        if (!Array.isArray(list)) return list;
        return list.map((c) => {
            const total = Number(c.totalNum) || Number(c.requiredNum) || 0;
            const done = Number(c.finishedNum) || 0;
            const progress = total > 0 ? Math.round((done / total) * 100) : 0;
            let status = 'pending';
            if (total > 0 && done >= total) status = 'done';
            else if (done > 0) status = 'doing';
            return Object.assign({}, c, {
                totalNum: total,
                requiredNum: total,
                finishedNum: done,
                pendingNum: Math.max(total - done, 0),
                progressPet: progress,
                status: status
            });
        });
    }
    // 已归一化的分类直接返回（幂等），未归一化的补字段
    function ensureNormalizedCategories(list) {
        if (!Array.isArray(list)) return list;
        if (list.length > 0 && typeof list[0].status === 'string') return list;
        return normalizeCategories(list);
    }

    const CategoryInfo = {
        data: [],
        tenantCode: null,
        userProjectId: null,

        parseURL() {
            const params = new URLSearchParams(window.location.search);
            const hash = window.location.hash;
            
            if (hash && hash.includes('userProjectId=')) {
                const hashParams = new URLSearchParams(hash.split('?')[1] || '');
                this.userProjectId = hashParams.get('userProjectId');
                this.tenantCode = hashParams.get('tenantCode');
            } else {
                this.userProjectId = params.get('userProjectId');
                this.tenantCode = params.get('tenantCode');
            }
            // URL 缺 tenantCode/userId 时从 localStorage['user'] 补齐
            fillStoredIdentity(this);
        },

        // 获取认证 token（与 ProjectInfo 共享）
        getAuthHeaders() {
            // 0) 优先 ajax-hook 捕获的站点真实 x-token，其次 localStorage 会话 token
            try { const captured = AjaxHooker.getToken('x-token'); if (captured) return captured; } catch (_) {}
            try { const storedFirst = readStoredToken(); if (storedFirst) return storedFirst; } catch (_) {}
            try {
                const iframe = document.querySelector('iframe.page-iframe, iframe[class*="iframe"]');
                if (iframe && iframe.contentWindow) {
                    const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
                    const metaToken = iframeDoc.querySelector('meta[name="x-token"]');
                    if (metaToken) {
                        return metaToken.content;
                    }
                }
            } catch (e) {}
            
            if (window.__authToken) {
                return window.__authToken;
            }
            
            const cookies = document.cookie.split(';');
            for (const cookie of cookies) {
                const [name, value] = cookie.trim().split('=');
                if (name === 'x-token' || name === 'token' || name === 'access_token') {
                    return value;
                }
            }
            
            return null;
        },

        async fetchDetails() {
            this.parseURL();
            if (!this.userProjectId) {
                Logger.debug('URL 中无 userProjectId 参数，无法获取分类');
                const cached = DataCache.load('category');
                if (cached && Array.isArray(cached) && cached.length > 0) {
                    this.data = ensureNormalizedCategories(cached);
                    Logger.debug('课程分类：使用本地缓存');
                    return this.data;
                }
                return [];
            }

            const authHeaders = this.getAuthHeaders();
            if (!authHeaders) {
                Logger.debug('未获取到认证 token，跳过课程分类获取');
                const cached = DataCache.load('category');
                if (cached && Array.isArray(cached) && cached.length > 0) {
                    this.data = ensureNormalizedCategories(cached);
                    Logger.debug('课程分类：使用本地缓存');
                    return cached;
                }
                return [];
            }

            try {
                const url = `https://weiban.mycourse.cn/pharos/usercourse/listCategory.do`;
                // 🔒 使用 GM_xmlhttpRequest 绕过浏览器风控检测
                const result = await new Promise((resolve, reject) => {
                    GM_xmlhttpRequest({
                        method: "POST",
                        url: url,
                        headers: {
                            "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
                            "x-token": authHeaders
                        },
                        data: `userProjectId=${this.userProjectId}&tenantCode=${this.tenantCode || ''}&userId=${this.userId || ''}&chooseType=3`,
                        responseType: "json",
                        onload: function (response) {
                            if (response.status >= 200 && response.status < 300) {
                                const responseData = response.response;
                                if (responseData && responseData.code && responseData.code !== "0") {
                                    reject(new Error(responseData.message || responseData.msg || '接口返回错误'));
                                } else {
                                    resolve(responseData);
                                }
                            } else {
                                reject(new Error(`HTTP ${response.status}`));
                            }
                        },
                        onerror: function (response) {
                            reject(new Error(`网络错误: ${response.statusText || '未知'}`));
                        }
                    });
                });

                if (result && Array.isArray(result.data)) {
                    this.data = normalizeCategories(result.data);
                    if (this.data.length > 0) DataCache.save('category', this.data);
                    Logger.info(`课程分类获取成功: 共 ${this.data.length} 个分类，未完成 ${this.data.filter(c => c.status !== 'done').length} 个`);
                    return this.data;
                } else {
                    Logger.debug(`课程分类 API 返回异常: ${JSON.stringify(result)}`);
                }
            } catch (e) {
                Logger.debug(`获取课程分类失败: ${e.message}`);
            }
            const cached = DataCache.load('category');
            if (cached && Array.isArray(cached) && cached.length > 0) {
                    this.data = ensureNormalizedCategories(cached);
                Logger.debug('课程分类：API 失败，使用本地缓存');
                return cached;
            }
            return [];
        },

        getDisplayInfo() {
            if (!this.data || this.data.length === 0) return null;
            
            const total = this.data.reduce((sum, cat) => sum + (cat.totalNum || 0), 0);
            const finished = this.data.reduce((sum, cat) => sum + (cat.finishedNum || 0), 0);
            const categories = this.data.map(cat => ({
                name: cat.categoryName,
                total: cat.totalNum || 0,
                finished: cat.finishedNum || 0,
                remark: cat.categoryRemark || ''
            }));
            
            return {
                categories,
                totalCourses: total,
                finishedCourses: finished,
                totalCategories: this.data.length
            };
        },

        // 获取指定分类的课程列表
        // 🔒 使用 GM_xmlhttpRequest 绕过浏览器风控检测
        async fetchCoursesByCategory(categoryCode) {
            if (!this.userProjectId) {
                this.parseURL();
            }

            const authHeaders = this.getAuthHeaders();
            if (!authHeaders) {
                Logger.debug('未获取到认证 token，跳过课程列表获取');
                return [];
            }

            try {
                const url = `https://weiban.mycourse.cn/pharos/usercourse/listCourse.do`;
                const result = await new Promise((resolve, reject) => {
                    GM_xmlhttpRequest({
                        method: "POST",
                        url: url,
                        headers: {
                            "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
                            "x-token": authHeaders
                        },
                        data: `userProjectId=${this.userProjectId}&tenantCode=${this.tenantCode || ''}&userId=${this.userId || ''}&chooseType=3&categoryCode=${categoryCode || ''}`,
                        responseType: "json",
                        onload: function (response) {
                            if (response.status >= 200 && response.status < 300) {
                                const responseData = response.response;
                                if (responseData && responseData.code && responseData.code !== "0") {
                                    reject(new Error(responseData.message || responseData.msg || '接口返回错误'));
                                } else {
                                    resolve(responseData);
                                }
                            } else {
                                reject(new Error(`HTTP ${response.status}`));
                            }
                        },
                        onerror: function (response) {
                            reject(new Error(`网络错误: ${response.statusText || '未知'}`));
                        }
                    });
                });

                if (result && Array.isArray(result.data)) {
                    Logger.debug(`课程列表获取成功: ${result.data.length} 个课程`);
                    return result.data;
                }
            } catch (e) {
                Logger.debug(`获取课程列表失败: ${e.message}`);
            }
            return [];
        },

        // 获取当前分类的所有课程
        // 🔒 使用 GM_xmlhttpRequest 绕过浏览器风控检测
        async fetchAllCourses() {
            this.parseURL();
            if (!this.userProjectId) return [];

            const authHeaders = this.getAuthHeaders();
            if (!authHeaders) {
                Logger.debug('未获取到认证 token，跳过所有课程获取');
                return [];
            }

            try {
                const url = `https://weiban.mycourse.cn/pharos/usercourse/listCourse.do`;
                const result = await new Promise((resolve, reject) => {
                    GM_xmlhttpRequest({
                        method: "POST",
                        url: url,
                        headers: {
                            "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
                            "x-token": authHeaders
                        },
                        data: `userProjectId=${this.userProjectId}&tenantCode=${this.tenantCode || ''}&userId=${this.userId || ''}&chooseType=3`,
                        responseType: "json",
                        onload: function (response) {
                            if (response.status >= 200 && response.status < 300) {
                                const responseData = response.response;
                                if (responseData && responseData.code && responseData.code !== "0") {
                                    reject(new Error(responseData.message || responseData.msg || '接口返回错误'));
                                } else {
                                    resolve(responseData);
                                }
                            } else {
                                reject(new Error(`HTTP ${response.status}`));
                            }
                        },
                        onerror: function (response) {
                            reject(new Error(`网络错误: ${response.statusText || '未知'}`));
                        }
                    });
                });

                if (result && Array.isArray(result.data)) {
                    Logger.info(`所有课程获取成功: ${result.data.length} 个课程`);
                    return result.data;
                }
            } catch (e) {
                Logger.debug(`获取所有课程失败: ${e.message}`);
            }
            return [];
        }
    };

    // ========== 学习助手/场景提示 ==========
    const StudyAssistant = {
        data: null,
        userId: null,
        tenantCode: null,
        userProjectId: null,
        sceneCategory: 2, // 默认场景分类

        parseURL() {
            const params = new URLSearchParams(window.location.search);
            const hash = window.location.hash;
            
            if (hash && hash.includes('userProjectId=')) {
                const hashParams = new URLSearchParams(hash.split('?')[1] || '');
                this.userProjectId = hashParams.get('userProjectId');
                this.tenantCode = hashParams.get('tenantCode');
                this.userId = hashParams.get('userId');
            } else {
                this.userProjectId = params.get('userProjectId');
                this.tenantCode = params.get('tenantCode');
                this.userId = params.get('userId');
            }
        },

        // 获取认证 token
        getAuthHeaders() {
            // 0) 优先 ajax-hook 捕获的站点真实 x-token，其次 localStorage 会话 token
            try { const captured = AjaxHooker.getToken('x-token'); if (captured) return captured; } catch (_) {}
            try { const storedFirst = readStoredToken(); if (storedFirst) return storedFirst; } catch (_) {}
            if (window.__authToken) {
                return window.__authToken;
            }
            const cookies = document.cookie.split(';');
            for (const cookie of cookies) {
                const [name, value] = cookie.trim().split('=');
                if (name === 'x-token' || name === 'token') {
                    return value;
                }
            }
            return null;
        },

        async fetchScene() {
            this.parseURL();
            if (!this.userId || !this.userProjectId) {
                Logger.debug('URL 中无 userId 或 userProjectId 参数');
                return null;
            }

            const authHeaders = this.getAuthHeaders();
            if (!authHeaders) {
                Logger.debug('未获取到认证 token，跳过场景提示获取');
                return null;
            }

            try {
                const url = `https://weiban.mycourse.cn/pharos/studyassistant/handle.do`;
                const resp = await AjaxHooker.apiFetch(url, {
                    method: 'POST',
                    credentials: 'include',
                    headers: Object.assign({}, AjaxHooker.getSiteHeaders(), {
                        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                        'x-token': authHeaders,
                        'Accept': 'application/json'
                    }),
                    body: `tenantCode=${this.tenantCode || ''}&userId=${this.userId}&sceneCategory=${this.sceneCategory}&userProjectId=${this.userProjectId}`
                });

                if (resp.ok) {
                    const result = await resp.json();
                    if (result.code === '0' && result.data) {
                        this.data = result.data;
                        Logger.debug(`学习助手场景获取成功: ${JSON.stringify(this.data)}`);
                        return this.data;
                    }
                }
            } catch (e) {
                Logger.debug(`获取学习助手场景失败: ${e.message}`);
            }
            return null;
        },

        // 检查是否所有课程已完成
        isAllCoursesCompleted() {
            if (!this.data || !this.data.sceneList) return false;
            return this.data.sceneList.some(scene => 
                scene.word && scene.word.includes('全部学习完毕')
            );
        },

        // 遍历所有分类拉取课程列表（接口驱动，含 finished 完成标记）
        // 参考微伴助手：支持多种 chooseType（3=必修，2=选修等）
        // 🔒 使用 GM_xmlhttpRequest 绕过浏览器风控检测
        async fetchCourses() {
            this.parseURL();
            fillStoredIdentity(this);
            if (!this.userProjectId) return [];
            const authHeaders = this.getAuthHeaders();
            if (!authHeaders) return [];
            
            // 封装 GM_xmlhttpRequest 为 Promise（与 turboCompleteCourse 保持一致）
            const makeRequest = (options) => {
                return new Promise((resolve, reject) => {
                    GM_xmlhttpRequest({
                        method: options.method || "POST",
                        url: options.url,
                        headers: options.headers || {
                            "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
                            "x-token": authHeaders
                        },
                        data: options.data,
                        responseType: "json",
                        onload: function (response) {
                            if (response.status >= 200 && response.status < 300) {
                                const responseData = response.response;
                                if (responseData && responseData.code && responseData.code !== "0") {
                                    reject(new Error(responseData.message || responseData.msg || '接口返回错误'));
                                } else {
                                    resolve(responseData);
                                }
                            } else {
                                reject(new Error(`HTTP ${response.status}`));
                            }
                        },
                        onerror: function (response) {
                            reject(new Error(`网络错误: ${response.statusText || '未知'}`));
                        }
                    });
                });
            };
            
            // 微伴助手使用的课程类型：3=必修课程，2=选修课程
            const COURSE_TYPES = ['3', '2'];
            const all = [];
            const seen = new Set();
            
            // 先获取所有分类（按 chooseType）
            const fetchCategories = async (chooseType) => {
                try {
                    const url = 'https://weiban.mycourse.cn/pharos/usercourse/listCategory.do';
                    const result = await makeRequest({
                        url: url,
                        data: `tenantCode=${this.tenantCode || ''}&userId=${this.userId || ''}&userProjectId=${this.userProjectId}&chooseType=${chooseType}`
                    });
                    if (result && Array.isArray(result.data)) {
                        return result.data.map(cat => ({ ...cat, chooseType }));
                    }
                } catch (_) {}
                return [];
            };
            
            // 按分类获取课程
            const fetchCoursesByCategory = async (categoryCode, chooseType) => {
                try {
                    const url = 'https://weiban.mycourse.cn/pharos/usercourse/listCourse.do';
                    const result = await makeRequest({
                        url: url,
                        data: `userProjectId=${this.userProjectId}&tenantCode=${this.tenantCode || ''}&userId=${this.userId || ''}&chooseType=${chooseType}${categoryCode ? `&categoryCode=${categoryCode}` : ''}`
                    });
                    if (result && Array.isArray(result.data)) {
                        for (const c of result.data) {
                            const key = c.userCourseId || c.resourceId || '';
                            if (!key || seen.has(key)) continue;
                            seen.add(key);
                            c.categoryCode = categoryCode || c.categoryCode || '';
                            c.chooseType = chooseType;
                            all.push(c);
                        }
                    }
                } catch (_) {}
            };
            
            // 遍历所有课程类型和分类
            for (const type of COURSE_TYPES) {
                try {
                    // 获取该类型下的所有分类
                    const categories = await fetchCategories(type);
                    try { Logger.debug(`[接口] 类型 ${type}: 找到 ${categories.length} 个分类`); } catch (_) {}
                    
                    if (categories.length > 0) {
                        // 按分类获取课程
                        for (const cat of categories) {
                            await fetchCoursesByCategory(cat.categoryCode || '', type);
                        }
                    } else {
                        // 无分类时直接获取该类型的所有课程
                        await fetchCoursesByCategory('', type);
                    }
                } catch (e) {
                    try { Logger.debug(`[接口] 类型 ${type} 获取失败: ${e.message}`); } catch (_) {}
                }
            }
            
            // 未完成 = finished !== 1（站点 1=完成，2=未完成）
            const pending = all.filter((c) => Number(c.finished) !== 1);
            this.allCourses = all;
            this.pendingCourses = pending;
            try { Logger.info(`[接口] 课程列表: 共 ${all.length} 个，未完成 ${pending.length} 个`); } catch (_) {}
            return all;
        },

        // 取未完成课程列表
        getPendingCourses() {
            return (this.pendingCourses && this.pendingCourses.length > 0) ? this.pendingCourses : [];
        },

        // 通过 getCourseUrl.do 拿到指定课程的学习页 URL
        // 🔒 使用 GM_xmlhttpRequest 绕过浏览器风控检测
        async getCourseUrl(course) {
            if (!course) return null;
            this.parseURL();
            fillStoredIdentity(this);
            const authHeaders = this.getAuthHeaders();
            if (!authHeaders) return null;
            const courseId = course.resourceId || course.courseId || '';
            
            try {
                const url = `https://weiban.mycourse.cn/pharos/usercourse/getCourseUrl.do?timestamp=${Date.now()}`;
                const result = await new Promise((resolve, reject) => {
                    GM_xmlhttpRequest({
                        method: "POST",
                        url: url,
                        headers: {
                            "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
                            "x-token": authHeaders
                        },
                        data: `tenantCode=${this.tenantCode || ''}&userId=${this.userId || ''}&courseId=${courseId}&userProjectId=${this.userProjectId}`,
                        responseType: "json",
                        onload: function (response) {
                            if (response.status >= 200 && response.status < 300) {
                                const responseData = response.response;
                                if (responseData && responseData.code && responseData.code !== "0") {
                                    reject(new Error(responseData.message || responseData.msg || '接口返回错误'));
                                } else {
                                    resolve(responseData);
                                }
                            } else {
                                reject(new Error(`HTTP ${response.status}`));
                            }
                        },
                        onerror: function (response) {
                            reject(new Error(`网络错误: ${response.statusText || '未知'}`));
                        }
                    });
                });
                
                if (result && result.data) return String(result.data);
            } catch (e) {
                try { Logger.debug(`getCourseUrl 失败: ${e.message}`); } catch (_) {}
            }
            return null;
        },

        // 获取提示消息
        getPromptMessage() {
            if (!this.data || !this.data.sceneList || this.data.sceneList.length === 0) {
                return null;
            }
            return this.data.sceneList.map(scene => scene.word).join('\n');
        },

        // ========== 极速模式：登录跳转鉴权 ==========
        // 极速模式依赖 weiban 域登录态（localStorage['user'] 里的 token）。
        // 无 token 时：标记「待登录续跑」，跳转 weiban 首页完成登录后自动回到刷课流程。
        // 用 GM_setValue 持久化（跨域 localStorage 隔离，但 GM 存储是共享的）。
        PendingTurboLogin: {
            KEY: 'shuake_pending_turbo',
            set(reason) {
                try { GM_setValue(this.KEY, JSON.stringify({ reason: reason || '', ts: Date.now() })); } catch (_) {}
            },
            get() {
                try {
                    const raw = GM_getValue(this.KEY, null);
                    if (!raw) return null;
                    const o = typeof raw === 'string' ? SafeJSON.parse(raw, null) : raw;
                    return (o && typeof o === 'object') ? o : null;
                } catch (_) { return null; }
            },
            clear() {
                try { GM_deleteValue(this.KEY); } catch (_) {}
            },
            // 跳转 weiban 首页完成登录（同 tab 跳转，避免丢失刷课上下文；登录后自动续跑）
            redirectToLogin(reason) {
                const msg = reason || '极速模式需要登录';
                try { showFloatToast(`极速模式需要登录: ${msg}`); } catch (_) {}
                try { Logger.warning(`[极速模式] ${msg}，跳转登录页，登录后自动继续刷课`); } catch (_) {}
                this.set(msg);
                try { window.top.location.href = 'https://weiban.mycourse.cn/'; } catch (_) {
                    try { window.location.href = 'https://weiban.mycourse.cn/'; } catch (_) {}
                }
            }
        },

        // ========== 极速模式：直接调用接口完成课程 ==========
        // 仿照微伴助手的快速完成机制：study.do → 等待 → v2/{id}.do
        // 🔒 使用 GM_xmlhttpRequest 绕过浏览器风控检测
        async turboCompleteCourse(course) {
            if (!course) return { success: false, message: '无课程数据' };
            
            this.parseURL();
            fillStoredIdentity(this);
            const authHeaders = this.getAuthHeaders();
            if (!authHeaders) {
                // 【登录跳转鉴权】无 token 时引导登录（跳 weiban 首页），登录后自动续跑
                try { this.PendingTurboLogin?.redirectToLogin('未检测到登录状态'); } catch (_) {}
                return { success: false, message: '无认证 token，已引导登录', needsLogin: true };
            }

            const courseId = course.resourceId || course.courseId || '';
            const userCourseId = course.userCourseId || '';
            const courseName = course.resourceName || '未命名课程';

            if (!courseId || !userCourseId) {
                return { success: false, message: '课程 ID 缺失' };
            }

            // 封装 GM_xmlhttpRequest 为 Promise（仿照微伴助手）
            const makeRequest = (options) => {
                return new Promise((resolve, reject) => {
                    GM_xmlhttpRequest({
                        method: options.method || "POST",
                        url: options.url,
                        headers: options.headers || {
                            "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
                            "x-token": authHeaders
                        },
                        data: options.data,
                        responseType: options.responseType || "json",
                        onload: function (response) {
                            if (response.status >= 200 && response.status < 300) {
                                let responseData = response.response;
                                if (options.responseType === 'text') {
                                    try {
                                        const text = response.responseText;
                                        responseData = JSON.parse(text.substring(text.indexOf('(') + 1, text.lastIndexOf(')')));
                                    } catch (e) {
                                        resolve(response.responseText);
                                        return;
                                    }
                                }
                                if (responseData && responseData.code && responseData.code !== "0") {
                                    reject(new Error(responseData.message || responseData.msg || '接口返回错误'));
                                } else {
                                    resolve(responseData);
                                }
                            } else {
                                reject(new Error(`HTTP ${response.status}`));
                            }
                        },
                        onerror: function (response) {
                            reject(new Error(`网络错误: ${response.statusText || '未知'}`));
                        }
                    });
                });
            };

            try {
                // 1. 调用 study.do 开始学习
                Logger.info(`[极速] 开始学习: ${courseName}`);
                const studyUrl = `https://weiban.mycourse.cn/pharos/usercourse/study.do?timestamp=${Date.now()}`;
                await makeRequest({
                    url: studyUrl,
                    data: `tenantCode=${this.tenantCode || ''}&userId=${this.userId || ''}&courseId=${courseId}&userProjectId=${this.userProjectId}`
                });

                // 2. 随机延迟 15-25 秒模拟学习
                const [minDelay, maxDelay] = CONFIG.turboModeDelay;
                const delay = Math.floor(Math.random() * (maxDelay - minDelay) + minDelay);
                Logger.info(`[极速] 模拟学习中: ${courseName} (${Math.floor(delay/1000)}秒)`);
                
                await new Promise(resolve => setTimeout(resolve, delay));

                // 3. 调用 v2/{userCourseId}.do 完成课程（JSONP格式）
                // 与 sdk.js finish() 完全同款：userCourseId + tenantCode + uniqueNo(页面有全局 uuid 时)
                Logger.info(`[极速] 提交完成: ${courseName}`);
                let _uuid = '';
                try { const u = (typeof unsafeWindow !== 'undefined' && unsafeWindow.uuid) || window.uuid; if (u) _uuid = String(u); } catch (_) {}
                const completeUrl = `https://weiban.mycourse.cn/pharos/usercourse/v2/${userCourseId}.do?callback=jQuery&userCourseId=${userCourseId}&tenantCode=${this.tenantCode || ''}${_uuid ? `&uniqueNo=${encodeURIComponent(_uuid)}` : ''}&_=${Date.now()}`;
                try {
                    await makeRequest({
                        method: "GET",
                        url: completeUrl,
                        responseType: 'text'
                    });
                } catch (e) {
                    Logger.warning(`[极速] v2 接口调用异常: ${e.message}（可能正常，继续验证）`);
                }

                // 4. 等待 5 秒后验证完成状态
                await new Promise(resolve => setTimeout(resolve, 5000));

                // 5. 验证课程是否完成（最多重试 3 次）
                for (let i = 0; i < 3; i++) {
                    try {
                        const listCourseUrl = `https://weiban.mycourse.cn/pharos/usercourse/listCourse.do?timestamp=${Date.now()}`;
                        const verifyResult = await makeRequest({
                            url: listCourseUrl,
                            data: `tenantCode=${this.tenantCode || ''}&userId=${this.userId || ''}&userProjectId=${this.userProjectId}&chooseType=${course.chooseType || '3'}&categoryCode=${course.categoryCode || ''}`
                        });

                        if (verifyResult && verifyResult.data && Array.isArray(verifyResult.data)) {
                            const updated = verifyResult.data.find(c => c.userCourseId === userCourseId);
                            if (updated && Number(updated.finished) === 1) {
                                Logger.success(`[极速] ✅ 课程已完成: ${courseName}`);
                                return { success: true, message: '课程完成成功' };
                            }
                            Logger.warning(`[极速] 验证尝试 ${i + 1}/3: 状态为 ${updated?.finished ?? '未知'}`);
                        }
                    } catch (e) {
                        Logger.warning(`[极速] 验证尝试 ${i + 1}/3 失败: ${e.message}`);
                    }

                    if (i < 2) await new Promise(resolve => setTimeout(resolve, 4000));
                }

                return { success: false, message: '完成状态验证失败（可能已完成但接口延迟）' };

            } catch (e) {
                Logger.error(`[极速] 完成课程异常: ${e.message}`);
                return { success: false, message: `异常: ${e.message}` };
            }
        }
    };

    // ========== 考试管理 ==========
    // 基于 pharos/exam/listPrePlan.do；论文题目/试卷详情接口见 docs/api.md
    const ExamManager = {
        data: [], // 缓存的考试列表
        userId: null,
        tenantCode: null,
        userProjectId: null,
        xToken: null,

        parseURL() {
            const params = new URLSearchParams(window.location.search);
            const hash = window.location.hash;
            if (hash && hash.includes('userProjectId=')) {
                const hashParams = new URLSearchParams(hash.split('?')[1] || '');
                this.userProjectId = hashParams.get('userProjectId');
                this.tenantCode = hashParams.get('tenantCode');
                this.userId = hashParams.get('userId');
            } else {
                this.userProjectId = params.get('userProjectId');
                this.tenantCode = params.get('tenantCode');
                this.userId = params.get('userId');
            }
            // URL 缺 tenantCode/userId 时从 localStorage['user'] 补齐
            fillStoredIdentity(this);
        },

        getAuthHeaders() {
            // 0) 优先 ajax-hook 捕获的站点真实 x-token，其次 localStorage 会话 token
            try { const captured = AjaxHooker.getToken('x-token'); if (captured) return captured; } catch (_) {}
            try { const storedFirst = readStoredToken(); if (storedFirst) return storedFirst; } catch (_) {}
            try {
                if (window.__authToken) return window.__authToken;
                const cookies = document.cookie.split(';');
                for (const cookie of cookies) {
                    const [name, value] = cookie.trim().split('=');
                    if (name === 'x-token' || name === 'token') return value;
                }
            } catch (e) {}
            return null;
        },

        async fetchList() {
            this.parseURL();
            if (!this.userId || !this.userProjectId) {
                try { Logger.debug('ExamManager: 缺少 userId/userProjectId'); } catch (_) {}
                const cached = DataCache.load('exam');
                if (cached && Array.isArray(cached) && cached.length > 0) {
                    this.data = cached;
                    try { Logger.debug('考试列表：使用本地缓存'); } catch (_) {}
                    return cached;
                }
                return [];
            }
            const token = this.getAuthHeaders();
            if (!token) {
                try { Logger.debug('ExamManager: 无 token，跳过'); } catch (_) {}
                const cached = DataCache.load('exam');
                if (cached && Array.isArray(cached) && cached.length > 0) {
                    this.data = cached;
                    try { Logger.debug('考试列表：使用本地缓存'); } catch (_) {}
                    return cached;
                }
                return [];
            }

            try {
                const token2 = token;
                // 正式考试：listPlan.do（如"结课考试"，HAR 实测返回 data 数组）
                const planUrl = 'https://weiban.mycourse.cn/pharos/exam/listPlan.do';
                const planResp = await AjaxHooker.apiFetch(planUrl, {
                    method: 'POST',
                    credentials: 'include',
                    headers: {
                        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                        'x-token': token2,
                        'Accept': 'application/json'
                    },
                    body: `tenantCode=${this.tenantCode || ''}&userId=${this.userId}&userProjectId=${this.userProjectId}`
                });
                let planList = [];
                if (planResp.ok) {
                    try {
                        const pr = await planResp.json();
                        if (pr.code === '0' && Array.isArray(pr.data)) {
                            planList = pr.data.map((e) => ({
                                id: e.id || e.examPlanId || e.examId || '',
                                examPlanId: e.examPlanId || e.id || '',
                                userExamPlanId: e.id || e.examPlanId || '',
                                examId: e.examId || '',
                                examName: e.examPlanName || e.examName || e.name || '考试',
                                examStatus: e.examStatus || e.status || '待考',
                                examStartTime: e.startTime || e.examStartTime || '',
                                examEndTime: e.endTime || e.examEndTime || '',
                                limitTime: e.answerTime || e.limitTime || 0,
                                passScore: e.passScore || 0,
                                answerNum: e.answerNum || 0,
                                canExam: e.canExam || 0,
                                examScore: e.examScore || 0,
                                type: 'plan',
                                raw: e
                            }));
                        }
                    } catch (_) {}
                } else {
                    try { Logger.debug(`ExamManager: listPlan HTTP ${planResp.status}`); } catch (_) {}
                }

                // 预考：listPrePlan.do（hasPreExam=1 才有）
                const url = 'https://weiban.mycourse.cn/pharos/exam/listPrePlan.do';
                const resp = await AjaxHooker.apiFetch(url, {
                    method: 'POST',
                    credentials: 'include',
                    headers: {
                        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                        'x-token': token,
                        'Accept': 'application/json'
                    },
                    body: `tenantCode=${this.tenantCode || ''}&userId=${this.userId}&userProjectId=${this.userProjectId}&chooseType=3`
                });
                let preList = [];
                if (resp.ok) {
                    try {
                        const result = await resp.json();
                        if (result.code === '0' && result.data && result.data.hasPreExam === 1 && Array.isArray(result.data.examList)) {
                            preList = result.data.examList.map((e) => ({
                                id: e.id || e.examPlanId || e.examId || '',
                                examPlanId: e.examPlanId || e.id || '',
                                userExamPlanId: e.id || e.examPlanId || '',
                                examId: e.examId || '',
                                examName: e.examName || e.name || '预考',
                                examStatus: e.examStatus || e.status || '待考',
                                examStartTime: e.examStartTime || '',
                                examEndTime: e.examEndTime || '',
                                limitTime: e.limitTime || 0,
                                passScore: e.passScore || 0,
                                answerNum: e.answerNum || 0,
                                canExam: e.canExam || 0,
                                examScore: e.examScore || 0,
                                type: 'pre',
                                raw: e
                            }));
                        }
                    } catch (_) {}
                } else {
                    try { Logger.debug(`ExamManager: listPrePlan HTTP ${resp.status}${(resp.status===401||resp.status===463) ? '（token 无效或跨域网关拦截）' : ''}`); } catch (_) {}
                }

                // 合并：预考在前，正式考试在后
                this.data = preList.concat(planList);
                if (this.data.length > 0) DataCache.save('exam', this.data);
                try { Logger.info(`ExamManager: 获取到 ${this.data.length} 个考试（预考${preList.length} + 正式${planList.length}）`); } catch (_) {}
                return this.data;
            } catch (e) {
                try { Logger.debug(`ExamManager.fetchList 失败: ${e.message}`); } catch (_) {}
            }
            const cached = DataCache.load('exam');
            if (cached && Array.isArray(cached) && cached.length > 0) {
                this.data = cached;
                try { Logger.debug('考试列表：API 失败，使用本地缓存'); } catch (_) {}
                return cached;
            }
            return [];
        },

        // 骨架方法：拉取试卷详情（若 docs/api.md 后续补充接口 URL，在此实现）
        // 当前未在面板 UI 中触发
        async fetchPaper(examPlanId) {
            try { Logger.warning('ExamManager.fetchPaper: 暂未对接考试详情接口（docs/api.md 缺失）'); } catch (_) {}
            return null;
        }
    };

    // ========== 试卷题目预取与预解析（HAR 实测：startPaper.do 一次返回全部题目） ==========
    // 拦截站点 startPaper.do 响应 → 提取全卷干净题干/选项 → 本地题库+缓存预解析答案；
    // DOM 逐题作答时按题干匹配，用 API 干净数据查询，显著提升命中率。
    const ExamPaper = {
        questions: [],   // [{id,title,type,typeLabel,sequence,options:[{id,content}]}]
        answers: {},     // qHash -> answer 字母串（预解析）
        resolvedCount: 0,
        ts: 0,

        reset() {
            this.questions = [];
            this.answers = {};
            this.resolvedCount = 0;
            this.ts = 0;
        },

        // 从 startPaper.do 响应 data 提取全卷
        ingest(data) {
            if (!data || !Array.isArray(data.questionList) || data.questionList.length === 0) return 0;
            this.questions = data.questionList.map((q) => ({
                id: q.id || '',
                title: String(q.title || '').trim(),
                type: Number(q.type) || 1,
                typeLabel: q.typeLabel || '',
                score: q.score || 0,
                sequence: Number(q.sequence) || 0,
                options: Array.isArray(q.optionList)
                    ? q.optionList.map((o) => ({ id: o.id || '', content: String(o.content || '').trim() })).filter((o) => o.content)
                    : []
            })).filter((q) => q.title);
            this.answers = {};
            this.resolvedCount = 0;
            this.ts = Date.now();
            try { Logger.info(`[试卷] 获取全卷 ${this.questions.length} 题（startPaper.do）`); } catch (_) {}
            return this.questions.length;
        },

        // 归一化题干（去空白/小写）
        _norm(t) { return String(t || '').replace(/\s+/g, '').toLowerCase(); },

        // 用当前 DOM 题匹配全卷题目（标题包含/前缀匹配，返回最可靠一条）
        match(domsText, domOptions) {
            if (!domsText || this.questions.length === 0) return null;
            const t = this._norm(domsText).slice(0, 160);
            if (!t) return null;
            let best = null, bestScore = 0;
            for (const q of this.questions) {
                const qt = this._norm(q.title);
                if (!qt) continue;
                let score = 0;
                if (t.includes(qt)) score = qt.length * 2;          // DOM 文本完整包含题干 → 最可靠
                else if (qt.includes(t)) score = t.length;          // 题干包含 DOM 文本（题干更完整）
                else {
                    const n = Math.min(14, qt.length, t.length);
                    if (n >= 6 && qt.slice(0, n) === t.slice(0, n)) score = n; // 前缀截断匹配
                }
                if (score > bestScore) { bestScore = score; best = q; }
            }
            return (best && bestScore >= 8) ? best : null;
        },

        // 预解析全部题目答案：本地题库 + AI 缓存（即时免费，不触发 AI 扣费）；AI/云端留待轮到时异步解析
        preResolve() {
            if (this.questions.length === 0) return 0;
            for (const q of this.questions) {
                try {
                    const opts = q.options.map((o) => o.content);
                    if (typeof AIAnswer === 'undefined' || typeof AIAnswer.generateQuestionHash !== 'function') continue;
                    const hash = AIAnswer.generateQuestionHash(q.title, opts);
                    let ans = null;
                    const rec = (typeof AIAnswer.getLocalAnswer === 'function') ? AIAnswer.getLocalAnswer(q.title, opts) : null;
                    if (rec && rec.answer) ans = String(rec.answer);
                    if (!ans && State.aiAnswerCache && State.aiAnswerCache.has(hash)) ans = String(State.aiAnswerCache.get(hash) || '');
                    if (ans) {
                        this.answers[hash] = ans;
                        this.resolvedCount++;
                    }
                } catch (_) {}
            }
            try { Logger.info(`[试卷] 预解析完成：${this.resolvedCount}/${this.questions.length} 题命中本地题库/缓存`); } catch (_) {}
            return this.resolvedCount;
        },

        // 按 hash 取预解析答案
        getPreAnswer(qHash) {
            return (qHash && this.answers[qHash]) ? this.answers[qHash] : null;
        }
    };


/* ============================================================
 * 【生产内联】面板代码（自动生成，请勿手动修改）
 * 源文件：panel/utils.js, panel/store.js, panel/PanelApp.js, panel/panel.css
 * 生成方式：node panel/build-prod.js
 * ============================================================ */
const ShuaKePanelCSS = "/* =========================================================\n * ShuaKe Panel - 自定义样式（全 TDesign 组件适配）\n *\n * 开发模式：作为独立文件 <link rel=\"stylesheet\" href=\"panel/panel.css\"> 引入\n * 生产模式：内联到 main.user.js 中\n *\n * 设计原则：\n *   1. 所有样式锁定在 #shuake-panel 子树，避免污染宿主页\n *   2. TDesign 组件统一做紧凑化（小字体 / 小间距），匹配面板 320px 宽度\n *   3. 保留毛玻璃质感与原面板的视觉基调\n * ========================================================= */\n\n/* ==== 面板容器：毛玻璃 + 圆角 + 阴影 ==== */\n#shuake-panel {\n    position: fixed !important;\n    top: 20px !important;\n    right: 20px !important;\n    width: 320px !important;\n    max-height: 88vh !important;\n    background: rgba(255, 255, 255, 0.78) !important;\n    backdrop-filter: saturate(180%) blur(20px) !important;\n    -webkit-backdrop-filter: saturate(180%) blur(20px) !important;\n    border: 0.5px solid rgba(0, 0, 0, 0.08) !important;\n    border-radius: 14px !important;\n    box-shadow:\n        0 0 0 0.5px rgba(0, 0, 0, 0.04),\n        0 2px 8px rgba(0, 0, 0, 0.04),\n        0 8px 32px rgba(0, 0, 0, 0.08) !important;\n    z-index: 999999 !important;\n    font-family: -apple-system, BlinkMacSystemFont, 'SF Pro Display', 'SF Pro Text', 'Helvetica Neue', sans-serif !important;\n    font-size: 12px !important;\n    color: #1d1d1f !important;\n    overflow: hidden !important;\n    transition: max-height 0.3s cubic-bezier(0.25, 0.1, 0.25, 1), box-shadow 0.3s !important;\n}\n#shuake-panel.sk-minimized {\n    max-height: 48px !important;\n}\n#shuake-panel:hover {\n    box-shadow:\n        0 0 0 0.5px rgba(0, 0, 0, 0.04),\n        0 4px 12px rgba(0, 0, 0, 0.06),\n        0 12px 40px rgba(0, 0, 0, 0.1) !important;\n}\n\n/* ==== 头部 ==== */\n#shuake-panel .sk-header {\n    display: flex;\n    justify-content: space-between;\n    align-items: center;\n    padding: 10px 14px;\n    background: transparent;\n    cursor: move;\n    user-select: none;\n    border-bottom: 0.5px solid rgba(0, 0, 0, 0.06);\n}\n#shuake-panel .sk-title {\n    font-weight: 600;\n    font-size: 13px;\n    color: #1d1d1f;\n    display: flex;\n    align-items: center;\n    gap: 6px;\n}\n#shuake-panel .sk-title-icon {\n    font-size: 14px;\n}\n#shuake-panel .sk-header-actions {\n    display: flex;\n    gap: 2px;\n    align-items: center;\n}\n/* 头部图标按钮：t-button 紧凑化 */\n#shuake-panel .sk-header-actions .t-button {\n    width: 26px;\n    height: 26px;\n    padding: 0 !important;\n    font-size: 13px;\n    color: #86868b;\n    background: transparent !important;\n}\n#shuake-panel .sk-header-actions .t-button:hover {\n    color: #007aff;\n    background: rgba(0, 122, 255, 0.08) !important;\n}\n\n/* ==== 调试徽章 ==== */\n#shuake-panel .sk-debug-badge {\n    margin-left: 4px;\n}\n\n/* ==== 工具栏（暂停/停止） ==== */\n#shuake-panel .sk-toolbar {\n    display: flex;\n    gap: 8px;\n    padding: 0 14px 10px;\n}\n#shuake-panel .sk-toolbar .t-button {\n    flex: 1;\n}\n\n/* ==== Tabs ==== */\n#shuake-panel .sk-tabs-wrap {\n    padding: 0 14px;\n}\n#shuake-panel .sk-tabs-wrap .t-tabs__nav {\n    background: rgba(0, 0, 0, 0.04);\n    border-radius: 8px;\n    padding: 2px;\n}\n#shuake-panel .sk-tabs-wrap .t-tabs__nav-item {\n    flex: 1;\n    justify-content: center;\n    font-size: 12px;\n    padding: 4px 8px;\n}\n#shuake-panel .sk-tabs-wrap .t-tabs__nav-item-wrapper--selected {\n    background: #fff;\n    border-radius: 6px;\n    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08);\n}\n#shuake-panel .sk-tabs-wrap .t-tabs__nav-item-wrapper--selected .t-tabs__nav-item {\n    color: #1d1d1f;\n    font-weight: 500;\n}\n\n/* ==== 滚动区 ==== */\n#shuake-panel .sk-body {\n    padding: 4px 14px 14px;\n    max-height: calc(88vh - 110px);\n    overflow-y: auto;\n    overflow-x: hidden;\n}\n#shuake-panel .sk-body::-webkit-scrollbar {\n    width: 4px;\n}\n#shuake-panel .sk-body::-webkit-scrollbar-thumb {\n    background: rgba(0, 0, 0, 0.12);\n    border-radius: 2px;\n}\n#shuake-panel .sk-body::-webkit-scrollbar-track {\n    background: transparent;\n}\n\n/* ==== 状态 alert ==== */\n#shuake-panel .sk-status-alert {\n    margin: 8px 0;\n    border-radius: 10px;\n}\n#shuake-panel .sk-status-alert .t-alert__message {\n    font-size: 12px;\n    font-weight: 500;\n}\n#shuake-panel .sk-status-line {\n    font-size: 12px;\n    font-weight: 600;\n    word-break: break-all;\n}\n#shuake-panel .sk-status-line strong {\n    line-height: 1.4;\n}\n#shuake-panel .sk-status-detail {\n    font-size: 10px;\n    font-weight: 400;\n    color: #6e6e73;\n    margin-top: 2px;\n    word-break: break-all;\n}\n\n/* ==== TDesign 卡片紧凑化 ==== */\n#shuake-panel .sk-tcard {\n    margin: 8px 0;\n    border-radius: 10px;\n    background: rgba(255, 255, 255, 0.6);\n}\n#shuake-panel .sk-tcard .t-card__header {\n    padding: 8px 12px;\n}\n#shuake-panel .sk-tcard .t-card__title {\n    font-size: 12px;\n    font-weight: 600;\n    color: #1d1d1f;\n}\n#shuake-panel .sk-tcard .t-card__body {\n    padding: 8px 12px 10px;\n}\n#shuake-panel .sk-tcard-title {\n    display: flex;\n    align-items: center;\n    gap: 6px;\n    max-width: 100%;\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n}\n\n/* ==== t-descriptions 紧凑 ==== */\n#shuake-panel .sk-desc {\n    font-size: 11px;\n}\n#shuake-panel .sk-desc .t-descriptions__label {\n    color: #86868b;\n    font-weight: 400;\n    white-space: nowrap;\n}\n#shuake-panel .sk-desc .t-descriptions__content {\n    color: #1d1d1f;\n}\n\n/* ==== t-progress ==== */\n#shuake-panel .sk-progress {\n    margin: 8px 0 2px;\n}\n#shuake-panel .sk-progress-foot {\n    display: flex;\n    justify-content: space-between;\n    font-size: 10px;\n    color: #86868b;\n    margin-top: 2px;\n}\n#shuake-panel .sk-cat-progress {\n    margin: 4px 0 8px;\n}\n\n/* ==== 统计网格 ==== */\n#shuake-panel .sk-stat-grid {\n    display: grid;\n    grid-template-columns: 1fr 1fr;\n    gap: 6px;\n}\n#shuake-panel .sk-stat-cell {\n    background: rgba(0, 0, 0, 0.03);\n    border-radius: 8px;\n    padding: 6px 10px;\n    text-align: center;\n}\n#shuake-panel .sk-stat-title {\n    font-size: 10px;\n    color: #86868b;\n    margin-bottom: 2px;\n}\n#shuake-panel .sk-stat-num {\n    font-size: 16px;\n    font-weight: 600;\n    color: #007aff;\n    line-height: 1.2;\n}\n#shuake-panel .sk-stat-num.sk-err-ok {\n    color: #34c759;\n}\n#shuake-panel .sk-stat-num.sk-err-warn {\n    color: #ff9500;\n}\n#shuake-panel .sk-stat-num.sk-err-err {\n    color: #ff3b30;\n}\n\n/* ==== t-collapse 紧凑 ==== */\n#shuake-panel .sk-tcollapse {\n    margin: 8px 0;\n    border-radius: 10px;\n    overflow: hidden;\n    background: rgba(255, 255, 255, 0.6);\n}\n#shuake-panel .sk-tcollapse .t-collapse-panel__header {\n    padding: 9px 12px;\n    font-size: 12px;\n    font-weight: 500;\n    color: #1d1d1f;\n    transition: background 0.15s;\n}\n#shuake-panel .sk-tcollapse .t-collapse-panel__header:hover {\n    background: rgba(0, 0, 0, 0.02);\n}\n#shuake-panel .sk-tcollapse .t-collapse-panel__header-right-content {\n    font-size: 10px;\n    margin-left: 6px;\n}\n#shuake-panel .sk-tcollapse .t-collapse-panel__content {\n    padding: 6px 12px 10px;\n    font-size: 12px;\n}\n\n/* ==== 表单 ==== */\n#shuake-panel .sk-field {\n    margin-bottom: 8px;\n}\n#shuake-panel .sk-field-row {\n    display: flex;\n    gap: 8px;\n}\n#shuake-panel .sk-field-row > * {\n    flex: 1;\n}\n#shuake-panel .sk-field-label {\n    display: block;\n    margin-bottom: 4px;\n    font-size: 11px;\n    color: #86868b;\n    font-weight: 500;\n}\n\n/* ==== 设置开关行 ==== */\n#shuake-panel .sk-setting-row {\n    display: flex;\n    justify-content: space-between;\n    align-items: center;\n    padding: 6px 0;\n    border-bottom: 0.5px solid rgba(0, 0, 0, 0.04);\n}\n#shuake-panel .sk-setting-row:last-child {\n    border-bottom: none;\n}\n#shuake-panel .sk-setting-label {\n    font-size: 12px;\n    color: #1d1d1f;\n}\n\n/* ==== 按钮组 ==== */\n#shuake-panel .sk-btn-row {\n    display: flex;\n    gap: 6px;\n    margin: 8px 0;\n}\n#shuake-panel .sk-btn-row .t-button {\n    flex: 1;\n}\n\n/* ==== 题目列表 ==== */\n#shuake-panel .sk-q-list {\n    max-height: 240px;\n    overflow-y: auto;\n}\n#shuake-panel .sk-q-list::-webkit-scrollbar {\n    width: 4px;\n}\n#shuake-panel .sk-q-list::-webkit-scrollbar-thumb {\n    background: rgba(0, 0, 0, 0.15);\n    border-radius: 2px;\n}\n#shuake-panel .sk-q-list .t-list__inner {\n    padding: 4px;\n}\n#shuake-panel .sk-q-item {\n    flex-direction: column;\n    align-items: stretch !important;\n    padding: 6px 8px;\n    font-size: 10px;\n    line-height: 1.4;\n}\n#shuake-panel .sk-q-item:hover {\n    background: rgba(0, 0, 0, 0.03);\n    border-radius: 4px;\n}\n#shuake-panel .sk-q-text {\n    color: #1d1d1f;\n    word-break: break-all;\n    display: flex;\n    align-items: center;\n    flex-wrap: wrap;\n    gap: 4px;\n}\n#shuake-panel .sk-q-content {\n    display: -webkit-box;\n    -webkit-line-clamp: 2;\n    -webkit-box-orient: vertical;\n    overflow: hidden;\n    flex: 1;\n    min-width: 0;\n}\n#shuake-panel .sk-q-meta {\n    display: flex;\n    justify-content: space-between;\n    margin-top: 4px;\n    font-size: 9px;\n    color: #86868b;\n}\n#shuake-panel .sk-ans {\n    color: #007aff;\n    font-weight: 600;\n}\n#shuake-panel .sk-verified {\n    color: #34c759;\n}\n\n/* ==== 日志 ==== */\n#shuake-panel .sk-logs-toolbar {\n    display: flex;\n    gap: 4px;\n    align-items: center;\n    margin-bottom: 6px;\n}\n#shuake-panel .sk-logs-toolbar .t-input {\n    flex: 1;\n}\n#shuake-panel .sk-logs-list {\n    max-height: 300px;\n    overflow-y: auto;\n    background: rgba(0, 0, 0, 0.03);\n    border-radius: 6px;\n}\n#shuake-panel .sk-logs-list::-webkit-scrollbar {\n    width: 4px;\n}\n#shuake-panel .sk-logs-list::-webkit-scrollbar-thumb {\n    background: rgba(0, 0, 0, 0.12);\n    border-radius: 2px;\n}\n#shuake-panel .sk-logs-list .t-list__inner {\n    padding: 2px;\n}\n#shuake-panel .sk-log-entry {\n    padding: 5px 8px;\n    font-size: 11px;\n    color: #1d1d1f;\n    line-height: 1.4;\n    display: flex;\n    gap: 6px;\n    align-items: flex-start;\n}\n#shuake-panel .sk-log-icon {\n    flex-shrink: 0;\n    width: 12px;\n    text-align: center;\n    opacity: 0.8;\n}\n#shuake-panel .sk-log-time {\n    color: #86868b;\n    font-size: 10px;\n    flex-shrink: 0;\n}\n#shuake-panel .sk-log-msg {\n    flex: 1;\n    word-break: break-all;\n}\n#shuake-panel .sk-log-count {\n    flex-shrink: 0;\n    background: rgba(0, 122, 255, 0.12);\n    color: #007aff;\n    font-size: 9px;\n    font-weight: 600;\n    border-radius: 6px;\n    padding: 0 4px;\n    margin-left: 4px;\n}\n#shuake-panel .sk-log-actions {\n    margin-top: 4px;\n    justify-content: flex-end;\n    width: 100%;\n}\n\n/* ==== 分类列表 ==== */\n#shuake-panel .sk-cat-list {\n    max-height: 140px;\n    overflow-y: auto;\n    margin-top: 6px;\n}\n#shuake-panel .sk-cat-list::-webkit-scrollbar {\n    width: 4px;\n}\n#shuake-panel .sk-cat-list::-webkit-scrollbar-thumb {\n    background: rgba(0, 0, 0, 0.12);\n    border-radius: 2px;\n}\n#shuake-panel .sk-cat-item {\n    padding: 6px 8px;\n    border-bottom: 0.5px solid rgba(0, 0, 0, 0.04);\n    font-size: 10px;\n    color: #86868b;\n}\n#shuake-panel .sk-cat-item:last-child {\n    border-bottom: none;\n}\n#shuake-panel .sk-cat-head {\n    display: flex;\n    justify-content: space-between;\n    align-items: center;\n    margin-bottom: 4px;\n}\n#shuake-panel .sk-cat-name {\n    font-weight: 500;\n    color: #1d1d1f;\n    word-break: break-all;\n}\n#shuake-panel .sk-cat-sub {\n    display: flex;\n    justify-content: space-between;\n    align-items: center;\n    font-size: 10px;\n    color: #86868b;\n    margin: 2px 0;\n}\n#shuake-panel .sk-cat-sub-inline {\n    font-weight: 400;\n    color: #86868b;\n    margin-left: 6px;\n    font-size: 10px;\n}\n#shuake-panel .sk-cat-list .sk-cat-item:hover {\n    background: rgba(0, 0, 0, 0.03);\n    border-radius: 4px;\n}\n\n/* ==== 考试列表 ==== */\n#shuake-panel .sk-exam-item {\n    display: flex;\n    justify-content: space-between;\n    align-items: center;\n    padding: 6px 8px;\n    border-radius: 6px;\n    margin-bottom: 4px;\n    background: rgba(0, 0, 0, 0.02);\n    font-size: 11px;\n}\n#shuake-panel .sk-exam-item:hover {\n    background: rgba(0, 0, 0, 0.05);\n}\n#shuake-panel .sk-exam-name {\n    flex: 1;\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n    margin-right: 8px;\n}\n\n/* ==== 快捷键 ==== */\n#shuake-panel .sk-shortcut-grid {\n    display: grid;\n    grid-template-columns: 1fr;\n    gap: 4px;\n    font-size: 11px;\n}\n#shuake-panel .sk-shortcut-row {\n    display: flex;\n    align-items: center;\n    padding: 4px 0;\n    border-bottom: 0.5px solid rgba(0, 0, 0, 0.04);\n}\n#shuake-panel .sk-shortcut-row:last-child {\n    border-bottom: none;\n}\n#shuake-panel .sk-key {\n    background: rgba(0, 0, 0, 0.05);\n    border: 0.5px solid rgba(0, 0, 0, 0.1);\n    border-radius: 4px;\n    padding: 1px 6px;\n    font-family: ui-monospace, \"SF Mono\", monospace;\n    font-size: 10px;\n    font-weight: 500;\n    color: #1d1d1f;\n    flex-shrink: 0;\n}\n#shuake-panel .sk-shortcut-desc {\n    flex: 1;\n    margin-left: 10px;\n    color: #86868b;\n}\n#shuake-panel .sk-hint {\n    margin-top: 8px;\n    font-size: 10px;\n    color: #86868b;\n}\n\n/* ==== 迷你统计条（题库顶部） ==== */\n#shuake-panel .sk-mini-stats {\n    display: grid;\n    grid-template-columns: 1fr 1fr 1fr 1fr;\n    gap: 6px;\n}\n#shuake-panel .sk-mini-item {\n    background: rgba(0, 0, 0, 0.03);\n    border-radius: 8px;\n    padding: 6px 8px;\n    text-align: center;\n    font-size: 10px;\n    color: #86868b;\n}\n#shuake-panel .sk-mini-label {\n    display: block;\n    margin-bottom: 2px;\n}\n#shuake-panel .sk-mini-value {\n    font-size: 14px;\n    font-weight: 600;\n    color: #1d1d1f;\n}\n#shuake-panel .sk-mini-ok {\n    color: #007aff;\n}\n\n/* ==== 答题结果统计行 ==== */\n#shuake-panel .sk-answer-stats {\n    display: grid;\n    grid-template-columns: 1fr 1fr 1fr;\n    gap: 6px;\n    margin-top: 8px;\n    padding-top: 8px;\n    border-top: 1px dashed rgba(0, 0, 0, 0.08);\n}\n#shuake-panel .sk-answer-stat {\n    background: rgba(0, 0, 0, 0.03);\n    border-radius: 8px;\n    padding: 6px 8px;\n    text-align: center;\n}\n#shuake-panel .sk-answer-label {\n    display: block;\n    font-size: 10px;\n    color: #86868b;\n    margin-bottom: 2px;\n}\n#shuake-panel .sk-answer-value {\n    font-size: 14px;\n    font-weight: 600;\n    color: #1d1d1f;\n}\n#shuake-panel .sk-answer-ok {\n    color: #34c759;\n}\n#shuake-panel .sk-answer-fail {\n    color: #ff3b30;\n}\n\n/* ==== 筛选条 ==== */\n#shuake-panel .sk-search {\n    margin-bottom: 8px;\n}\n#shuake-panel .sk-filter-block {\n    margin: 6px 0;\n}\n#shuake-panel .sk-filter-block .t-radio-button {\n    font-size: 11px;\n    padding: 0 10px;\n}\n\n/* ==== 最近答题 / AI 结果 alert ==== */\n#shuake-panel .sk-last-alert,\n#shuake-panel .sk-ai-alert {\n    font-size: 11px;\n    margin: 4px 0;\n}\n#shuake-panel .sk-last-alert .t-alert__title,\n#shuake-panel .sk-ai-alert .t-alert__title {\n    font-size: 11px;\n}\n#shuake-panel .sk-last-time {\n    margin-top: 4px;\n    opacity: 0.7;\n    font-size: 10px;\n}\n\n/* ==== 空态紧凑化：隐藏 t-empty 插图，仅保留文字 ==== */\n#shuake-panel .t-empty {\n    padding: 6px 0;\n}\n#shuake-panel .t-empty__image {\n    display: none;\n}\n#shuake-panel .t-empty__description {\n    font-size: 11px;\n    color: #86868b;\n}\n\n/* ==== 隐藏面板时的悬浮恢复按钮（fav 组件）====\n * 注意：此元素独立于 #shuake-panel 子树，因为面板隐藏时（display:none）\n * 其内部所有子元素都不可见，恢复入口必须作为 body 下的独立悬浮元素。\n * 由 ControlPanel._syncFloatFav() 控制显隐与位置（跟随面板最后拖拽位置）。 */\n#shuake-fav-float {\n    position: fixed !important;\n    top: 20px !important;\n    right: 20px !important;\n    width: 36px !important;\n    height: 36px !important;\n    display: flex !important;\n    align-items: center !important;\n    justify-content: center !important;\n    border-radius: 50% !important;\n    background: rgba(255, 255, 255, 0.9) !important;\n    backdrop-filter: saturate(180%) blur(20px) !important;\n    -webkit-backdrop-filter: saturate(180%) blur(20px) !important;\n    border: 0.5px solid rgba(0, 0, 0, 0.08) !important;\n    box-shadow:\n        0 2px 8px rgba(0, 0, 0, 0.12),\n        0 8px 24px rgba(0, 0, 0, 0.08) !important;\n    z-index: 999999 !important;\n    cursor: pointer !important;\n    font-size: 16px !important;\n    line-height: 1 !important;\n    color: #ff9500 !important;\n    user-select: none !important;\n    transition: transform 0.15s ease, box-shadow 0.2s ease !important;\n}\n#shuake-fav-float:hover {\n    transform: scale(1.08) !important;\n    box-shadow:\n        0 4px 12px rgba(0, 0, 0, 0.16),\n        0 10px 28px rgba(0, 0, 0, 0.10) !important;\n}\n#shuake-fav-float:active {\n    transform: scale(0.96) !important;\n}\n\n/* ==== t-select 下拉弹层（attach body 后挂 body 下，非 #shuake-panel 子树） ==== */\n/* 面板容器 overflow:hidden 会裁剪内部弹层，故弹层 attach 到 body；此层 z-index 需高于面板(999999)盖住页面其他 fixed 元素 */\n.sk-select-popup {\n    z-index: 1000000 !important;\n}\n.sk-select-popup .t-select__dropdown {\n    font-size: 12px;\n    border-radius: 8px;\n    overflow: hidden;\n}\n.sk-select-popup .t-select-option {\n    padding: 6px 10px;\n    font-size: 12px;\n}\n";

/* ===== panel/utils.js ===== */
/**
 * ShuaKe Panel - 工具函数
 * 命名空间：window.ShuaKePanel.utils
 *
 * 开发模式：作为独立文件 <script src="panel/utils.js"> 引入
 * 生产模式：内联到 main.user.js 中
 */
(function () {
    'use strict';

    const ns = (window.ShuaKePanel = window.ShuaKePanel || {});

    /**
     * HTML 转义，防止 XSS
     */
    function escapeHtml(text) {
        if (text == null) return '';
        return String(text)
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;')
            .replace(/'/g, '&#39;');
    }

    /**
     * 安全 JSON 解析
     */
    function safeParse(text, fallback) {
        if (text == null) return fallback;
        try {
            return JSON.parse(text);
        } catch (_) {
            return fallback;
        }
    }

    /**
     * 安全 JSON 序列化
     */
    function safeStringify(obj, fallback) {
        try {
            return JSON.stringify(obj);
        } catch (_) {
            return fallback || '{}';
        }
    }

    /**
     * 格式化时间戳为 HH:MM:SS
     */
    function formatTime(date) {
        const d = date instanceof Date ? date : new Date(date);
        if (isNaN(d.getTime())) return '--:--';
        const pad = (n) => String(n).padStart(2, '0');
        return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
    }

    /**
     * 格式化日期时间
     */
    function formatDateTime(date) {
        const d = date instanceof Date ? date : new Date(date);
        if (isNaN(d.getTime())) return '-';
        return d.toLocaleString('zh-CN', { hour12: false });
    }

    /**
     * 限制日志条数
     */
    function trimArray(arr, max) {
        if (arr.length > max) {
            arr.splice(max, arr.length - max);
        }
        return arr;
    }

    /**
     * 数字限制在范围
     */
    function clamp(v, min, max) {
        v = Number(v);
        if (isNaN(v)) return min;
        return Math.max(min, Math.min(max, v));
    }

    /**
     * 深拷贝（仅支持 JSON 安全的数据）
     */
    function deepClone(obj) {
        return safeParse(safeStringify(obj), obj);
    }

    /**
     * 题目类型映射
     */
    const TYPE_LABEL = {
        single: '单选',
        multi: '多选',
        judge: '判断',
        fill: '填空'
    };

    const SOURCE_LABEL = {
        local: '本地',
        ai: 'AI',
        manual: '手动',
        cloud: '云端'
    };

    /**
     * 日志级别配置
     */
    const LEVEL_CONFIG = {
        error:   { label: '错误', icon: 'close-circle', theme: 'danger' },
        warning: { label: '警告', icon: 'warning', theme: 'warning' },
        success: { label: '成功', icon: 'check-circle', theme: 'success' },
        info:    { label: '信息', icon: 'info-circle', theme: 'primary' },
        debug:   { label: '调试', icon: 'bullet-point', theme: 'default' }
    };

    /**
     * AI 模型预设列表
     */
    const AI_MODEL_OPTIONS = [
        { label: 'qwen-plus', value: 'qwen-plus' },
        { label: 'qwen-turbo', value: 'qwen-turbo' },
        { label: 'qwen-max', value: 'qwen-max' },
        { label: 'gpt-4o-mini', value: 'gpt-4o-mini' },
        { label: 'gpt-4o', value: 'gpt-4o' },
        { label: '自定义...', value: '__custom__' }
    ];

    ns.utils = {
        escapeHtml,
        safeParse,
        safeStringify,
        formatTime,
        formatDateTime,
        trimArray,
        clamp,
        deepClone,
        TYPE_LABEL,
        SOURCE_LABEL,
        LEVEL_CONFIG,
        AI_MODEL_OPTIONS
    };
})();


/* ===== panel/store.js ===== */
/**
 * ShuaKe Panel - 响应式状态 Store
 * 命名空间：window.ShuaKePanel.createStore
 *
 * 将面板的全部 UI 状态集中到一个 reactive 对象里，
 * 外部 API（updateStatus、addLog 等）只修改这里，由 Vue 自动驱动渲染
 */
(function () {
    'use strict';

    const ns = (window.ShuaKePanel = window.ShuaKePanel || {});

    /**
     * 创建响应式状态对象
     * @param {Object} deps 依赖注入 { Vue, CONFIG, State, Statistics }
     */
    function createStore(deps) {
        const { Vue, CONFIG, State, Statistics } = deps;
        const cfg = CONFIG.aiConfig || {};

        const knownModels = ['qwen-plus', 'qwen-turbo', 'qwen-max', 'gpt-4o-mini', 'gpt-4o'];
        const modelVal = cfg.model || 'qwen-plus';
        const isCustom = !knownModels.includes(modelVal);

        return Vue.reactive({
            // ==== 状态指示 ====
            statusText: '准备中...',
            statusClass: '', // '' | 'paused' | 'error' | 'warning'
            running: State.isRunning, // 是否运行中（false → 显示"开始刷课"按钮）
            minimized: false,
            panelVisible: true, // 面板显示/隐藏（K 键 / 头部按钮），用于切换显示图标
            activeTab: 'main',
            debugBadgeVisible: !!CONFIG.debugMode,

            // ==== 项目 / 课程 ====
            projectInfo: null,
            courseInfo: {
                name: '加载中...',
                totalPage: '-',
                finishedPage: '-',
                totalTime: '-',
                progress: '-'
            },
            progress: 0,

            // ==== 统计 ====
            stats: {
                duration: '0:00',
                coursesCompleted: 0,
                pagesViewed: 0,
                errors: 0,
                lastErrorTime: null
            },

            // ==== 基础设置 ====
            debugMode: !!CONFIG.debugMode,
            autoNextCourse: !!CONFIG.autoNextCourse,
            turboMode: !!CONFIG.turboMode,
            realVideoPlay: CONFIG.realVideoPlay === true,
            checkInterval: CONFIG.checkInterval ?? 1200,
            pageTurnDelay: CONFIG.pageTurnDelay ?? 500,
            progressThreshold: Math.round((CONFIG.progressThreshold ?? 0.9) * 100),
            maxRetryAttempts: CONFIG.maxRetryAttempts ?? 5,
            minVideoPlayTime: CONFIG.minVideoPlayTime ?? 5000,
            videoPlaybackRate: CONFIG.videoPlaybackRate > 0 ? CONFIG.videoPlaybackRate : 2,
            courseRepeatLimit: CONFIG.courseRepeatLimit > 0 ? CONFIG.courseRepeatLimit : 3,
            canvasAutoBack: CONFIG.canvasAutoBack === true,

            // ==== AI 配置 ====
            aiAnswerEnabled: CONFIG.enableAIAnswer !== false,
            aiUrl: cfg.apiUrl || '',
            aiKey: cfg.apiKey || '',
            aiKeyVisible: false,
            aiModel: isCustom ? '__custom__' : modelVal,
            aiModelCustom: isCustom ? (cfg.model || '') : '',
            aiTimeout: cfg.timeout || 30000,
            aiRetries: cfg.maxRetries != null ? cfg.maxRetries : 2,
            aiTemp: cfg.temperature != null ? cfg.temperature : 0.1,
            aiMaxTokens: cfg.maxTokens || 50,
            aiUseDefaultPrompt: cfg.useDefaultPrompt !== false,
            aiPrompt: cfg.systemPrompt || '',
            aiStatusBadge: { type: 'off', text: '未配置' }, // {type: 'ok'|'off'|'err', text: string}
            aiLastResult: null, // { ok, ans?, error?, ms, time }
            // 云端 AI：本系统访问 API Key + AI 来源路由
            cloudApiKey: (CONFIG.cloudBank && CONFIG.cloudBank.apiKey) || '',
            cloudApiKeyVisible: false,
            cloudAvailableKeys: [],
            cloudApiKeyCustom: (CONFIG.cloudBank && CONFIG.cloudBank.apiKey) || '',
            sessionApiKeys: [],
            aiSource: 'auto',   // AI 答题来源：'auto' | 'cloud' | 'local'
            cloudAITesting: false,
            cloudAITestResult: null, // { ok, answer?, cost?, balance?, error?, time }

            // ==== 题库 ====
            bankLocal: 0,
            bankVerified: 0,
            bankHits: 0,
            bankLocalHits: 0,
            bankCloud: 0,
            bankAi: 0,
            bankRate: 0,
            bankCacheCount: 0,
            bankAICount: 0,
            // 答题结果统计（成功/失败/命中率）
            bankSuccess: 0,
            bankFailed: 0,
            bankAnswerRate: 0,
            bankListCount: 0,
            bankListTotal: 0,
            bankStatus: '未连接', // '已连接' | '未连接' | error
            bankStatusBadge: { type: 'off', text: '未连接' },
            bankCloudEnabled: !!(CONFIG.cloudBank && CONFIG.cloudBank.enabled),
            bankEndpoint: (CONFIG.cloudBank && CONFIG.cloudBank.endpoint) || '',
            bankAutoUpload: !!(CONFIG.cloudBank && CONFIG.cloudBank.autoUpload),
            bankQueryBefore: !!(CONFIG.cloudBank && CONFIG.cloudBank.queryBeforeAI),
            bankStrategy: (CONFIG.cloudBank && CONFIG.cloudBank.matchStrategy) || 'both',
            bankQuestions: [], // 过滤后的题目
            bankFilter: {
                q: '',
                type: 'all',
                source: 'all'
            },
            bankLastResult: null, // 最近一次答题

            // ==== 云端账户 ====
            cloudLoggedIn: false,
            cloudUser: null,
            cloudEmail: '',
            cloudPassword: '',
            cloudIncludeKey: false, // 同步时是否包含 API Key
            cloudStatusMsg: '',
            cloudProfile: null,
            studyReportMode: 'off',     // 刷课统计上报认证模式: api-key / jwt / guest / off
            // t-select 下拉弹层统一配置：attach 到 body（面板 overflow:hidden 会裁剪内部弹层）+ 高 z-index 盖住页面
            selectPopupProps: {
                attach: () => (typeof document !== 'undefined' ? document.body : undefined),
                zIndex: 1000000,
                overlayClassName: 'sk-select-popup'
            },
            cloudCode: '',              // 注册邮箱验证码
            cloudSendingCode: false,    // 发送验证码中
            cloudSendCodeMsg: '',       // 发送验证码结果提示

            // ==== 折叠面板 ====
            expandedCourse: true,
            expandedCloud: false,
            expandedLast: false,
            expandedBasic: true,
            expandedAI: false,
            expandedLogs: true,
            expandedShortcut: false,
            expandedCache: false,
            expandedVersion: false,
            versionInfo: {
                current: (typeof VersionChecker !== 'undefined') ? VersionChecker.current : '2.48',
                checking: false,
                latest: '',
                needUpdate: false,
                force: false,
                changelog: '',
                downloadUrl: '',
                fallbackUrl: '',
                minClientVersion: '',
                channel: 'stable',
                fileSha256: '',
                error: '',
                lastCheck: ''
            },

            // ==== 课程 / 任务 / 考试（由 refreshCoursePanel 填充，必须先初始化避免渲染崩溃）====
            courseSummary: null,       // { name, requiredFinishedNum, requiredNum, ... }
            courseCategories: [],      // CategoryInfo.data
            courseExams: [],           // ExamManager.data

            // ==== 日志 ====
            logSearch: '',
            logLevel: 'all',
            logPersist: CONFIG.logPersist !== false,      // 本地持久化日志
            logMax: CONFIG.logMax || 100,                 // 最大保留条数
            showDebugLogs: CONFIG.showDebugLogs !== false, // 面板显示 debug 级别
            logs: [] // { time, ts, message, level, icon, theme, count }

        });
    }

    /**
     * 根据状态生成日志级别过滤函数
     */
    function makeLogFilter(logSearch, logLevel) {
        const q = (logSearch || '').trim().toLowerCase();
        const lvl = logLevel || 'all';
        return function (entry) {
            const textMatch = !q || (entry.message || '').toLowerCase().includes(q);
            const levelMatch = lvl === 'all' || entry.level === lvl;
            return textMatch && levelMatch;
        };
    }

    /**
     * 根据状态生成题库过滤函数
     */
    function makeBankFilter(filter) {
        const q = (filter.q || '').trim().toLowerCase();
        const type = filter.type || 'all';
        const source = filter.source || 'all';
        return function (record) {
            if (!record || !record.qHash) return false;
            if (type !== 'all' && (record.type || 'single') !== type) return false;
            if (source !== 'all' && (record.source || 'local') !== source) return false;
            if (!q) return true;
            const inQ = (record.question || '').toLowerCase().includes(q);
            const inOpts = (record.options || []).some((o) => (o.content || '').toLowerCase().includes(q));
            const inA = (record.answer || '').toLowerCase().includes(q);
            return inQ || inOpts || inA;
        };
    }

    ns.createStore = createStore;
    ns.makeLogFilter = makeLogFilter;
    ns.makeBankFilter = makeBankFilter;
})();


/* ===== panel/PanelApp.js ===== */
/**
 * ShuaKe Panel - 主面板组件（Vue 3 + TDesign）
 * 命名空间：window.ShuaKePanel.PanelApp
 *
 * 包含完整的 Vue 模板与组件编排逻辑，
 * 通过 props/state 接收 store 并对外暴露给 main.user.js 使用。
 */
(function () {
    'use strict';

    const ns = (window.ShuaKePanel = window.ShuaKePanel || {});
    const { escapeHtml, formatTime, formatDateTime, TYPE_LABEL, SOURCE_LABEL, LEVEL_CONFIG, AI_MODEL_OPTIONS } =
        ns.utils;

    /**
     * 注册 TDesign 组件到 Vue 应用
     * 不同版本 tdesign-vue-next 的全局暴露方式略有差异：
     *   - 部分版本暴露 window.TDesign.default.create()
     *   - 部分版本暴露 window.TDesign（本身就是一个 install 函数）
     */
    function installTDesign(app, TDesignGlobal) {
        if (!app || !TDesignGlobal) return;
        try {
            if (typeof TDesignGlobal === 'function') {
                app.use(TDesignGlobal);
                return;
            }
            if (TDesignGlobal.default && typeof TDesignGlobal.default === 'function') {
                app.use(TDesignGlobal.default);
                return;
            }
            // 兜底：依次尝试常见的 install 字段
            const candidates = ['install', 'create'];
            for (const k of candidates) {
                if (typeof TDesignGlobal[k] === 'function') {
                    app.use(TDesignGlobal[k]);
                    return;
                }
            }
        } catch (e) {
            try { console.warn('[ShuaKePanel] TDesign 注册失败:', e); } catch (_) {}
        }
    }

    /**
     * 构建主面板组件
     * @param {Object} deps 依赖 { Vue, state, panel: ControlPanel, TD }
     */
    function buildPanelApp(deps) {
        const { Vue, state, panel, TD } = deps;
        // 防御：Vue 不完整时直接抛出让上层降级，绝不在此处解构崩溃（reading 'ref'）
        if (!Vue || typeof Vue.ref !== 'function' || typeof Vue.reactive !== 'function') {
            throw new Error('Vue API 不完整，无法构建面板');
        }
        const { ref, computed, watch, onMounted, nextTick } = Vue;

        const PanelApp = {
            components: TD || {},
            setup() {
                // 拖拽状态
                const dragState = { active: false, x: 0, y: 0, dx: 0, dy: 0 };
                const panelRoot = ref(null);

                const onHeaderMouseDown = (e) => {
                    // 按钮点击不触发拖拽（右侧动作区整体排除，避免误拖）
                    const t = e.target;
                    if (t && (t.closest('button') || t.closest('.t-button') || t.closest('.sk-header-actions'))) {
                        return;
                    }
                    const root = panelRoot.value;
                    if (!root) return;
                    const rect = root.getBoundingClientRect();
                    dragState.active = true;
                    dragState.x = e.clientX;
                    dragState.y = e.clientY;
                    // 用鼠标在面板内的相对偏移，避免 fixed+right 定位下 offsetLeft 失效
                    dragState.dx = e.clientX - rect.left;
                    dragState.dy = e.clientY - rect.top;
                    if (e.preventDefault) e.preventDefault();
                };

                const onDocMouseMove = (e) => {
                    if (!dragState.active) return;
                    const root = panelRoot.value;
                    if (!root) return;
                    // 【拖拽修复·双层容器】真正的 fixed 容器是外层 #shuake-panel（CSS top/right !important），
                    // 模板 root .sk-panel-root 是普通 div（静态定位），把 left/top 写到它无效。
                    // 故位置必须写到外层 host：#shuake-panel；同时 setProperty(...,'important') 覆盖 !important。
                    const host = (panel && panel.panel) || root.parentElement || root;
                    const _vw = window.innerWidth || 0;
                    const _vh = window.innerHeight || 0;
                    const _L = Math.max(0, Math.min(e.clientX - dragState.dx, _vw - 320 - 8));
                    const _T = Math.max(0, Math.min(e.clientY - dragState.dy, _vh - 64 - 8));
                    host.style.setProperty('left', `${_L}px`, 'important');
                    host.style.setProperty('top', `${_T}px`, 'important');
                    host.style.setProperty('right', 'auto', 'important');
                };
                const onDocMouseUp = () => {
                    dragState.active = false;
                    // 拖拽结束：把最终位置交给 ControlPanel 持久化（读外层 host：#shuake-panel 的位置）
                    try {
                        const root = panelRoot.value;
                        if (root && typeof panel.persistPosition === 'function') {
                            const host = (panel && panel.panel) || root.parentElement || root;
                            panel.persistPosition(host.style.left, host.style.top);
                        }
                    } catch (_) {}
                };

                onMounted(() => {
                    document.addEventListener('mousemove', onDocMouseMove);
                    document.addEventListener('mouseup', onDocMouseUp);
                    try {
                        // 暴露 root 给 panel 实例（用于刷新、状态同步等）
                        panel._root = panelRoot.value;
                    } catch (_) {}
                });

                // 通用：标签主题映射
                const tagTheme = (type) => {
                    // t-tag theme 仅支持 default/primary/warning/danger/success（无 purple/cyan）
                    return {
                        single: 'primary',
                        multi: 'success',
                        judge: 'warning',
                        fill: 'success',
                        local: 'success',
                        ai: 'warning',
                        manual: 'primary',
                        cloud: 'default'
                    }[type] || 'default';
                };

                // 状态徽章 → TDesign 合法 theme（ok/off/err 映射）
                const badgeTheme = (type) => {
                    return { ok: 'success', off: 'default', err: 'danger' }[type] || 'default';
                };

                // 工具方法
                const showTypeLabel = (t) => TYPE_LABEL[t] || t || '单选';
                const showSourceLabel = (s) => SOURCE_LABEL[s] || s || '本地';
                const showLevelTheme = (l) => (LEVEL_CONFIG[l] || {}).theme || 'default';
                const showLevelIcon = (l) => (LEVEL_CONFIG[l] || {}).icon || 'bullet-point';

                // ==== 全 TDesign 模板计算属性 ====

                // 运行状态 → t-alert 主题
                const statusTheme = computed(() => {
                    const cls = state.statusClass;
                    if (cls === 'error') return 'error';
                    if (cls === 'warning' || cls === 'paused') return 'warning';
                    return 'success';
                });

                // 最新一条日志（状态 alert 默认展示内容，避免一直"准备中..."）
                const latestLog = computed(() => {
                    const arr = state.logs || [];
                    return arr.length > 0 ? arr[0] : null;
                });

                // 状态 alert 主题：有日志用日志级别，无日志用运行状态
                const alertTheme = computed(() => {
                    const latest = latestLog.value;
                    if (latest) {
                        const t = (LEVEL_CONFIG[latest.level] || {}).theme || 'default';
                        if (t === 'danger') return 'error';
                        if (t === 'warning') return 'warning';
                        if (t === 'success') return 'success';
                        return 'info';
                    }
                    return statusTheme.value;
                });

                // 过滤后的日志（受 logSearch / logLevel 影响）
                const filteredLogs = computed(() => {
                    const kw = (state.logSearch || '').trim().toLowerCase();
                    const lvl = state.logLevel || 'all';
                    return (state.logs || []).filter((l) => {
                        if (lvl !== 'all' && l.level !== lvl) return false;
                        if (kw && !(l.message || '').toLowerCase().includes(kw)) return false;
                        return true;
                    });
                });

                // t-collapse 值数组 ↔ 布尔折叠状态 互转
                const mkCollapse = (getBool, setBool) => computed({
                    get: () => (getBool() ? ['1'] : []),
                    set: (v) => { setBool(Array.isArray(v) && v.includes('1')); }
                });
                const collapseCourse = mkCollapse(() => state.expandedCourse, (v) => { state.expandedCourse = v; });
                const collapseCloud = mkCollapse(() => state.expandedCloud, (v) => { state.expandedCloud = v; });
                const collapseLast = mkCollapse(() => state.expandedLast, (v) => { state.expandedLast = v; });
                const collapseBasic = mkCollapse(() => state.expandedBasic, (v) => { state.expandedBasic = v; });
                const collapseAI = mkCollapse(() => state.expandedAI, (v) => { state.expandedAI = v; });
                const collapseShortcut = mkCollapse(() => state.expandedShortcut, (v) => { state.expandedShortcut = v; });
                const collapseLogs = mkCollapse(() => state.expandedLogs, (v) => { state.expandedLogs = v; });
                const collapseCache = mkCollapse(() => state.expandedCache, (v) => { state.expandedCache = v; });
                const collapseVersion = mkCollapse(() => state.expandedVersion, (v) => { state.expandedVersion = v; });

                // 题库筛选选项
                const questionTypes = [
                    { value: 'all', label: '全部' },
                    { value: 'single', label: '单选' },
                    { value: 'multi', label: '多选' },
                    { value: 'judge', label: '判断' }
                ];
                const questionSources = [
                    { value: 'all', label: '全部' },
                    { value: 'local', label: '本地' },
                    { value: 'ai', label: 'AI' },
                    { value: 'manual', label: '手动' }
                ];

                // 最近答题结果 → t-alert 主题
                const lastResultTheme = computed(() => {
                    const t = (state.bankLastResult && state.bankLastResult.type) || 'ok';
                    if (t === 'fail') return 'error';
                    if (t === 'cloud') return 'info';
                    if (t === 'ai') return 'warning';
                    return 'success';
                });

                // 统计错误数颜色类
                const errorStatClass = computed(() => {
                    if (state.stats.errors > 5) return 'sk-err-err';
                    if (state.stats.errors > 0) return 'sk-err-warn';
                    return 'sk-err-ok';
                });

                // 快捷键列表
                const shortcuts = [
                    { key: 'P', desc: '暂停 / 继续' },
                    { key: 'S', desc: '停止刷课' },
                    { key: 'D', desc: '切换调试模式' },
                    { key: 'M', desc: '最小化 / 展开面板' },
                    { key: 'K', desc: '切换面板显示' },
                    { key: 'L', desc: '清空日志' },
                    { key: 'R', desc: '刷新项目数据' },
                    { key: 'A', desc: 'AI 答题开关' },
                    { key: 'T', desc: '测试 AI 连接' },
                    { key: '?', desc: '帮助（提示）' }
                ];

                // ==== 课程分类：接口字段归一化 + 排序 + 状态（兼容 normalizeCategories 未就绪的兜底）====
                const normCat = (c) => {
                    if (!c) return null;
                    if (c.status && c.totalNum != null) return c;
                    const total = Number(c.totalNum != null ? c.totalNum : c.requiredNum) || 0;
                    const done = Number(c.finishedNum) || 0;
                    const pending = Math.max(0, total - done);
                    const status = done >= total && total > 0 ? 'done' : (done > 0 ? 'doing' : 'pending');
                    return Object.assign({}, c, {
                        totalNum: total,
                        requiredNum: total,
                        finishedNum: done,
                        pendingNum: pending,
                        status
                    });
                };

                // 排序：未完成置顶（doing=0 < pending=1 < done=2），同 rank 按待完成数降序
                const sortedCategories = computed(() => {
                    const list = Array.isArray(state.courseCategories) ? state.courseCategories : [];
                    return list.map(normCat).filter(Boolean).sort((a, b) => {
                        const rank = { doing: 0, pending: 1, done: 2 };
                        const ra = rank[a.status] != null ? rank[a.status] : 1;
                        const rb = rank[b.status] != null ? rank[b.status] : 1;
                        if (ra !== rb) return ra - rb;
                        return (b.pendingNum || 0) - (a.pendingNum || 0);
                    });
                });

                // 状态 tag：已完成 / 待完成 N
                const catTag = (cat) => {
                    const c = normCat(cat);
                    if (!c) return { text: '', theme: 'default', icon: '' };
                    if (c.status === 'done') return { text: '已完成', theme: 'success', icon: 'check-circle' };
                    return { text: `待完成 ${c.pendingNum || 0}`, theme: c.status === 'doing' ? 'warning' : 'default', icon: 'time' };
                };

                // 进度现算（done/total*100）
                const catProgress = (cat) => {
                    const c = normCat(cat);
                    if (!c || !c.totalNum) return 0;
                    return Math.min(100, Math.round(((c.finishedNum || 0) / c.totalNum) * 100));
                };

                // 分类概要统计
                const categoryStats = computed(() => {
                    const list = Array.isArray(state.courseCategories) ? state.courseCategories : [];
                    let total = 0, done = 0, pending = 0;
                    for (const c of list) {
                        const n = normCat(c);
                        if (!n) continue;
                        total += 1;
                        if (n.status === 'done') done += 1;
                        else pending += 1;
                    }
                    return { total, done, pending };
                });

                // 版本模块：暴露响应式引用（versionInfo 在 state 中定义，模板直接引用需在此声明）
                const versionInfo = state.versionInfo;

                return {
                    // state
                    state,
                    panel,
                    panelRoot,
                    // 工具
                    escapeHtml,
                    formatTime,
                    formatDateTime,
                    tagTheme,
                    badgeTheme,
                    showTypeLabel,
                    showSourceLabel,
                    showLevelTheme,
                    showLevelIcon,
                    AI_MODEL_OPTIONS,
                    // 计算属性
                    statusTheme,
                    alertTheme,
                    latestLog,
                    filteredLogs,
                    collapseCourse,
                    collapseCloud,
                    collapseLast,
                    collapseBasic,
                    collapseAI,
                    collapseShortcut,
                    collapseLogs,
                    collapseCache,
                    collapseVersion,
                    versionInfo,
                    questionTypes,
                    questionSources,
                    lastResultTheme,
                    errorStatClass,
                    shortcuts,
                    sortedCategories,
                    catTag,
                    catProgress,
                    categoryStats,
                    // 事件
                    onHeaderMouseDown
                };
            },
            template: buildTemplate()
        };

        return PanelApp;
    }

    /**
     * 构建 Vue 模板字符串
     */
    /**
     * 构建 Vue 模板字符串（全 TDesign 组件化）
     */
    function buildTemplate() {
        return /* html */ `
        <div ref="panelRoot" class="sk-panel-root" :class="{ 'sk-minimized': state.minimized }">
            <!-- ====== 头部（拖拽） ====== -->
            <div class="sk-header" @mousedown="onHeaderMouseDown">
                <div class="sk-title">
                    <t-icon name="star-filled" style="font-size:14px;color:#ff9500;" />
                    <span>麦课助手</span>
                    <t-tag v-if="state.debugBadgeVisible" size="small" theme="warning" variant="light" class="sk-debug-badge">DEBUG</t-tag>
                </div>
                <div class="sk-header-actions">
                    <t-button size="small" variant="text" shape="square" :title="state.minimized ? '展开 (M)' : '最小化 (M)'" @click="panel.toggleMinimize()">
                        <t-icon :name="state.minimized ? 'add' : 'minus'" />
                    </t-button>
                    <t-button size="small" variant="text" shape="square" title="刷新状态" @click="panel.refreshAll()">
                        <t-icon name="refresh" />
                    </t-button>
                    <t-button size="small" variant="text" shape="square" title="切换显示 (K)" @click="panel.toggleVisible()">
                        <t-icon :name="state.panelVisible ? 'browse' : 'browse-off'" />
                    </t-button>
                </div>
            </div>

            <!-- ====== 工具栏：开始刷课 / 暂停继续 / 停止 ====== -->
            <div v-show="!state.minimized" class="sk-toolbar">
                <t-button v-if="!state.running" theme="success" size="small" block @click="panel.start()">
                    开始刷课
                </t-button>
                <template v-else>
                    <t-button theme="primary" size="small" block @click="panel.togglePause()">
                        {{ state.statusClass === 'paused' ? '继续' : '暂停' }}
                    </t-button>
                    <t-button theme="danger" size="small" variant="outline" block @click="panel.stop()">停止</t-button>
                </template>
            </div>

            <!-- ====== Tabs ====== -->
            <div v-show="!state.minimized" class="sk-tabs-wrap">
                <t-tabs v-model="state.activeTab" size="small" @change="panel.onTabChange($event)">
                    <t-tab-panel value="main" label="概览"></t-tab-panel>
                    <t-tab-panel value="course" label="课程"></t-tab-panel>
                    <t-tab-panel value="bank" label="题库"></t-tab-panel>
                    <t-tab-panel value="logs" label="日志"></t-tab-panel>
                    <t-tab-panel value="cloud" label="云端"></t-tab-panel>
                    <t-tab-panel value="settings" label="设置"></t-tab-panel>
                </t-tabs>
            </div>

            <!-- ====== 主体 ====== -->
            <div v-show="!state.minimized" class="sk-body">

                <!-- ============ 概览 Tab ============ -->
                <div v-show="state.activeTab === 'main'">
                    <!-- 状态 -->
                    <t-alert :theme="alertTheme" class="sk-status-alert">
                        <template #message>
                            <div class="sk-status-line">
                                <t-icon v-if="latestLog" :name="showLevelIcon(latestLog.level)" style="margin-right:4px;vertical-align:-2px;" />
                                <strong>{{ latestLog ? latestLog.message : state.statusText }}</strong>
                            </div>
                            <div v-if="latestLog && latestLog.time" class="sk-status-detail">{{ latestLog.time }}</div>
                            <div v-if="state.courseInfo && state.courseInfo.name && state.courseInfo.name !== '加载中...' && state.courseInfo.name !== '未知课程'" class="sk-status-detail">
                                当前课程：{{ state.courseInfo.name }}
                            </div>
                            <div v-if="state.courseInfo && state.courseInfo.progress !== '-' && Number(state.courseInfo.progress) > 0" class="sk-status-detail">
                                进度：{{ state.courseInfo.progress }}%（第 {{ state.courseInfo.finishedPage }}/{{ state.courseInfo.totalPage }} 页）
                            </div>
                        </template>
                    </t-alert>

                    <!-- 项目信息 -->
                    <t-card v-if="state.projectInfo" size="small" :bordered="true" class="sk-tcard">
                        <template #header>
                            <div class="sk-tcard-title" :title="state.projectInfo.name"><t-icon name="dashboard" style="color:#007aff;" />{{ state.projectInfo.name }}</div>
                        </template>
                        <t-descriptions size="small" :column="2" :colon="false" class="sk-desc">
                            <t-descriptions-item label="必修课程">{{ state.projectInfo.requiredFinishedNum }}/{{ state.projectInfo.requiredNum }}</t-descriptions-item>
                            <t-descriptions-item label="考试">{{ state.projectInfo.examFinishedNum }}/{{ state.projectInfo.examNum }}</t-descriptions-item>
                            <t-descriptions-item label="状态">{{ state.projectInfo.studyStateLabel || '未知' }}</t-descriptions-item>
                            <t-descriptions-item label="截止">{{ state.projectInfo.endTime || '-' }}</t-descriptions-item>
                        </t-descriptions>
                        <t-progress :percentage="Math.min(100, Number(state.projectInfo.progressPet) || 0)" size="small" :label="false" class="sk-progress" />
                        <div class="sk-progress-foot">
                            <span>{{ Number(state.projectInfo.progressPet) || 0 }}%</span>
                            <span>剩余 {{ state.projectInfo.lastDays || 0 }} 天</span>
                        </div>
                    </t-card>

                    <!-- 课程信息 -->
                    <t-card size="small" :bordered="true" class="sk-tcard">
                        <template #header>
                            <div class="sk-tcard-title" :title="state.courseInfo.name"><t-icon name="book" style="color:#34c759;" />{{ state.courseInfo.name }}</div>
                        </template>
                        <t-descriptions size="small" :column="2" :colon="false" class="sk-desc">
                            <t-descriptions-item label="总页数">{{ state.courseInfo.totalPage }}</t-descriptions-item>
                            <t-descriptions-item label="已完成">{{ state.courseInfo.finishedPage }}</t-descriptions-item>
                            <t-descriptions-item label="总时长">{{ state.courseInfo.totalTime }}</t-descriptions-item>
                            <t-descriptions-item label="进度">{{ state.courseInfo.progress !== '-' ? state.courseInfo.progress + '%' : '-' }}</t-descriptions-item>
                        </t-descriptions>
                    </t-card>

                    <!-- 当前进度 -->
                    <t-card size="small" :bordered="true" class="sk-tcard">
                        <template #header><div class="sk-tcard-title"><t-icon name="trend-up" style="color:#ff9500;" />当前进度</div></template>
                        <t-progress :percentage="Math.min(100, Number(state.progress) || 0)" size="small" class="sk-progress" />
                    </t-card>

                    <!-- 统计 -->
                    <t-card size="small" :bordered="true" class="sk-tcard">
                        <template #header><div class="sk-tcard-title"><t-icon name="chart-bar" style="color:#8e8e93;" />统计</div></template>
                        <div class="sk-stat-grid">
                            <div class="sk-stat-cell">
                                <div class="sk-stat-title">运行时长</div>
                                <div class="sk-stat-num">{{ state.stats.duration }}</div>
                            </div>
                            <div class="sk-stat-cell">
                                <div class="sk-stat-title">已完成课程</div>
                                <div class="sk-stat-num">{{ state.stats.coursesCompleted }}</div>
                            </div>
                            <div class="sk-stat-cell">
                                <div class="sk-stat-title">已翻页</div>
                                <div class="sk-stat-num">{{ state.stats.pagesViewed }}</div>
                            </div>
                            <div class="sk-stat-cell">
                                <div class="sk-stat-title">错误</div>
                                <div class="sk-stat-num" :class="errorStatClass"
                                     :title="state.stats.lastErrorTime ? ('最近错误：' + formatDateTime(state.stats.lastErrorTime)) : ''">
                                    {{ state.stats.errors }}
                                </div>
                            </div>
                        </div>
                        <div class="sk-btn-row">
                            <t-button size="small" variant="outline" block @click="panel.resetStats()">重置</t-button>
                            <t-button size="small" variant="outline" block @click="panel.exportStats()">导出统计</t-button>
                        </div>
                    </t-card>

                </div>

                <!-- ============ 课程 Tab ============ -->
                <div v-show="state.activeTab === 'course'">
                    <!-- 课程/任务/考试 -->
                    <t-collapse v-model="collapseCourse" class="sk-tcollapse">
                        <t-collapse-panel value="1" header="课程 / 任务 / 考试">
                            <div class="sk-field">
                                <div class="sk-field-label">项目总进度</div>
                                <t-descriptions v-if="state.courseSummary" size="small" :column="2" :colon="false" class="sk-desc">
                                    <t-descriptions-item label="必修">{{ state.courseSummary.requiredFinishedNum || 0 }}/{{ state.courseSummary.requiredNum || 0 }}</t-descriptions-item>
                                    <t-descriptions-item label="已完成">{{ state.courseSummary.finishedNum || 0 }}</t-descriptions-item>
                                    <t-descriptions-item label="总数">{{ state.courseSummary.totalNum || 0 }}</t-descriptions-item>
                                    <t-descriptions-item label="进度">{{ state.courseSummary.progressPet || 0 }}%</t-descriptions-item>
                                </t-descriptions>
                                <t-empty v-else description="暂无项目数据" :image-style="{ width: '44px' }" />
                            </div>
                            <div class="sk-field">
                                <div class="sk-field-label">课程分类
                                    <span v-if="categoryStats.total > 0" class="sk-cat-sub-inline">共 {{ categoryStats.total }} 个分类 · 已完成 {{ categoryStats.done }} / 待完成 {{ categoryStats.pending }}</span>
                                </div>
                                <t-empty v-if="state.courseCategories.length === 0" description="暂无分类" :image-style="{ width: '44px' }" />
                                <div v-else class="sk-cat-list">
                                    <div v-for="cat in sortedCategories" :key="cat.categoryCode || cat.id" class="sk-cat-item" :title="cat.categoryRemark">
                                        <div class="sk-cat-head">
                                            <span class="sk-cat-name">{{ cat.categoryName || cat.name || '未命名' }}</span>
                                            <t-tag size="small" :theme="catTag(cat).theme" variant="light">
                                                <t-icon :name="catTag(cat).icon" />
                                                {{ catTag(cat).text }}
                                            </t-tag>
                                        </div>
                                        <div class="sk-cat-sub">
                                            <span>{{ cat.finishedNum || 0 }}/{{ cat.totalNum || cat.requiredNum || 0 }} 已完成</span>
                                            <span>待完成 {{ cat.pendingNum || 0 }}</span>
                                        </div>
                                        <t-progress :percentage="catProgress(cat)" size="small" :label="false" :color="cat.status === 'done' ? ['#34c759', '#30b350'] : ['#ff9500', '#ff9500']" class="sk-cat-progress" />
                                    </div>
                                </div>
                            </div>
                            <div class="sk-field">
                                <div class="sk-field-label">考试列表</div>
                                <t-empty v-if="state.courseExams.length === 0" description="暂无考试" :image-style="{ width: '44px' }" />
                                <div v-else>
                                    <div v-for="exam in state.courseExams" :key="exam.id" class="sk-exam-item">
                                        <div class="sk-exam-name" :title="exam.examName || exam.name">{{ exam.examName || exam.name || '未命名考试' }}</div>
                                        <t-tag size="small" :theme="exam.canExam ? 'success' : 'warning'" variant="light">{{ exam.canExam ? '可考试' : '未开始' }}</t-tag>
                                    </div>
                                </div>
                            </div>
                            <div class="sk-btn-row">
                                <t-button size="small" variant="outline" block @click="panel.refreshProjectData()">刷新项目数据</t-button>
                            </div>
                        </t-collapse-panel>
                    </t-collapse>
                </div>


                <!-- ============ 题库 Tab ============ -->
                <div v-show="state.activeTab === 'bank'">
                    <!-- 题库总览 -->
                    <t-card size="small" :bordered="true" class="sk-tcard">
                        <template #header><div class="sk-tcard-title"><t-icon name="bookmark" style="color:#007aff;" />题库总览</div></template>
                        <div class="sk-mini-stats">
                            <div class="sk-mini-item">
                                <span class="sk-mini-label">本地</span>
                                <span class="sk-mini-value">{{ state.bankLocal }}</span>
                            </div>
                            <div class="sk-mini-item">
                                <span class="sk-mini-label">已验证</span>
                                <span class="sk-mini-value">{{ state.bankVerified }}</span>
                            </div>
                            <div class="sk-mini-item">
                                <span class="sk-mini-label">总命中</span>
                                <span class="sk-mini-value sk-mini-ok">{{ state.bankHits }}</span>
                            </div>
                            <div class="sk-mini-item">
                                <span class="sk-mini-label">本地命中</span>
                                <span class="sk-mini-value">{{ state.bankLocalHits }}</span>
                            </div>
                            <div class="sk-mini-item">
                                <span class="sk-mini-label">云端命中</span>
                                <span class="sk-mini-value">{{ state.bankCloud }}</span>
                            </div>
                            <div class="sk-mini-item">
                                <span class="sk-mini-label">AI 命中</span>
                                <span class="sk-mini-value">{{ state.bankAi }}</span>
                            </div>
                        </div>
                        <div class="sk-answer-stats">
                            <div class="sk-answer-stat">
                                <span class="sk-answer-label">答题成功</span>
                                <span class="sk-answer-value sk-answer-ok">{{ state.bankSuccess }}</span>
                            </div>
                            <div class="sk-answer-stat">
                                <span class="sk-answer-label">答题失败</span>
                                <span class="sk-answer-value sk-answer-fail">{{ state.bankFailed }}</span>
                            </div>
                            <div class="sk-answer-stat">
                                <span class="sk-answer-label">命中率</span>
                                <span class="sk-answer-value">{{ state.bankAnswerRate }}%</span>
                            </div>
                        </div>
                        <div class="sk-btn-row">
                            <t-button size="small" variant="outline" block @click="panel.exportBank()">导出</t-button>
                            <t-button size="small" variant="outline" block @click="panel.importBank()">导入</t-button>
                            <t-button size="small" variant="outline" block @click="panel.resetBankStats()">清统计</t-button>
                            <t-button size="small" theme="danger" variant="outline" block @click="panel.clearBank()">清空</t-button>
                        </div>
                    </t-card>

                    <!-- 筛选 -->
                    <t-card size="small" :bordered="true" class="sk-tcard">
                        <template #header><div class="sk-tcard-title"><t-icon name="filter" style="color:#8e8e93;" />筛选</div></template>
                        <t-input v-model="state.bankFilter.q" placeholder="搜索题干 / 选项 / 答案" size="small" clearable class="sk-search" />
                        <div class="sk-filter-block">
                            <t-radio-group v-model="state.bankFilter.type" size="small" variant="default-filled">
                                <t-radio-button v-for="t in questionTypes" :key="'t-' + t.value" :value="t.value">{{ t.label }}</t-radio-button>
                            </t-radio-group>
                        </div>
                        <div class="sk-filter-block">
                            <t-radio-group v-model="state.bankFilter.source" size="small" variant="default-filled">
                                <t-radio-button v-for="s in questionSources" :key="'s-' + s.value" :value="s.value">{{ s.label }}</t-radio-button>
                            </t-radio-group>
                        </div>
                    </t-card>

                    <!-- 题目列表 -->
                    <t-card size="small" :bordered="true" class="sk-tcard">
                        <template #header>
                            <div class="sk-tcard-title">
                                <t-icon name="file-copy" style="color:#8e8e93;" />题目列表
                                <t-tag size="small" theme="primary" variant="light" style="margin-left: 6px;">{{ state.bankListCount }}/{{ state.bankListTotal }}</t-tag>
                            </div>
                        </template>
                        <t-empty v-if="state.bankQuestions.length === 0" description="暂无题目" :image-style="{ width: '48px' }" />
                        <t-list v-else class="sk-q-list" :split="true">
                            <t-list-item v-for="r in state.bankQuestions" :key="r.qHash" class="sk-q-item">
                                <div class="sk-q-text">
                                    <t-tag size="small" :theme="tagTheme(r.type || 'single')" variant="light">{{ showTypeLabel(r.type) }}</t-tag>
                                    <t-tag size="small" :theme="tagTheme(r.source || 'local')" variant="light">{{ showSourceLabel(r.source) }}</t-tag>
                                    <t-icon v-if="r.verified" name="check-circle" class="sk-verified" style="color:#34c759;" />
                                    <span class="sk-q-content">{{ (r.question || '').slice(0, 120) }}</span>
                                </div>
                                <div class="sk-q-meta">
                                    <span>答案: <strong class="sk-ans">{{ r.answer || '?' }}</strong></span>
                                    <span>{{ r.updatedAt ? formatDateTime(r.updatedAt) : '-' }}</span>
                                    <t-button size="small" variant="text" :title="r.verified ? '取消已验证' : '标记已验证'" style="padding:0 2px;height:18px;font-size:11px;color:#34c759;" @click.stop="panel.toggleBankVerified(r.qHash)">
                                        <t-icon :name="r.verified ? 'check-circle' : 'circle'" />
                                    </t-button>
                                    <t-button size="small" variant="text" title="修改答案" style="padding:0 2px;height:18px;font-size:11px;color:#007aff;" @click.stop="panel.editBankAnswer(r.qHash)">
                                        <t-icon name="edit-1" />
                                    </t-button>
                                    <t-button size="small" variant="text" title="删除此题" style="padding:0 2px;height:18px;font-size:11px;color:#ff3b30;" @click.stop="panel.removeBankRecord(r.qHash)">
                                        <t-icon name="delete" />
                                    </t-button>
                                </div>
                            </t-list-item>
                        </t-list>
                    </t-card>
                    <!-- 最近答题 -->
                    <t-collapse v-model="collapseLast" class="sk-tcollapse">
                        <t-collapse-panel value="1" header="最近答题">
                            <t-alert v-if="state.bankLastResult" :theme="lastResultTheme" class="sk-last-alert">
                                <template #title><strong>{{ state.bankLastResult.title }}</strong></template>
                                <div v-if="state.bankLastResult.question">{{ state.bankLastResult.question }}</div>
                                <div v-if="state.bankLastResult.answer">答案: <strong class="sk-ans">{{ state.bankLastResult.answer }}</strong></div>
                                <div v-if="state.bankLastResult.time" class="sk-last-time">{{ state.bankLastResult.time }}</div>
                            </t-alert>
                            <t-empty v-else description="暂无答题记录" :image-style="{ width: '44px' }" />
                        </t-collapse-panel>
                    </t-collapse>
                </div>


                <!-- ============ 云端账户 Tab ============ -->
                <div v-show="state.activeTab === 'cloud'">
                    <!-- 刷课统计上报状态（对齐 API 文档） -->
                    <div class="sk-status-detail" style="font-size: 12px; margin-bottom: 8px; color: #5f5f5f; padding: 8px 10px; background: #f7f8fa; border-radius: 8px;">
                        刷课统计上报：<strong :style="state.studyReportMode === 'off' ? 'color:#ff3b30' : 'color:#34c759'">{{
                            state.studyReportMode === 'api-key' ? 'API Key（X-API-Key，免登录自动上报）' :
                            state.studyReportMode === 'jwt' ? '云端登录（JWT）自动上报' :
                            state.studyReportMode === 'guest' ? '游客（X-Guest-Id）上报' : '未启用（请在面板配置 API Key 或登录云端）'
                        }}</strong>
                    </div>
                    <!-- 已登录状态 -->
                    <template v-if="state.cloudLoggedIn">
                        <t-alert theme="success" class="sk-tcard" style="margin-bottom: 8px;">
                            <template #message>
                                <strong>已登录云端账户</strong>
                                <div v-if="state.cloudProfile" style="font-size: 12px; margin-top: 4px; line-height: 1.7;">
                                    <div>邮箱：{{ state.cloudProfile.email }}</div>
                                    <div v-if="state.cloudProfile.username">用户名：{{ state.cloudProfile.username }}</div>
                                    <div>角色：{{ state.cloudProfile.role === 'admin' ? '管理员' : (state.cloudGuest ? '游客（微伴自动注册）' : '普通用户') }}</div>
                                    <div v-if="state.cloudGuest" style="color: #ff9f0a;">游客账号：官方题库免费但每日限 100 次，注册正式账号不限量；不支持充值 AI 答题</div>
                                    <div v-if="state.cloudGuest" style="margin-top: 8px; padding: 8px; background: rgba(255,159,10,0.08); border-radius: 8px;">
                                        <div style="font-size: 12px; line-height: 1.7; color: #8a6d1a;">当前为游客登录态，AI 答题需注册正式账号并充值额度。</div>
                                        <div class="sk-btn-row" style="margin-top: 6px;">
                                            <t-button size="small" theme="primary" block @click="panel.cloudRegister()">注册用户（正式账号不限量）</t-button>
                                            <t-button size="small" theme="warning" block @click="panel.cloudOpenLogin()">充值 AI 额度</t-button>
                                        </div>
                                        <div style="font-size: 11px; color: #8e8e93; margin-top: 4px;">注册/登录/充值均在网页完成：mk.heymeta.cn</div>
                                    </div>
                                    <div>余额：¥{{ (state.cloudProfile.balance || 0).toFixed(2) }}</div>
                                </div>
                                <div v-else-if="state.cloudUser" style="font-size: 12px; margin-top: 4px; line-height: 1.7;">
                                    <div>邮箱：{{ state.cloudUser.email || state.cloudUser.username || '已登录' }}</div>
                                    <div v-if="state.cloudUser.role">角色：{{ state.cloudUser.role === 'admin' ? '管理员' : '普通用户' }}</div>
                                </div>
                                <div v-if="state.bankEndpoint" style="font-size: 12px; margin-top: 4px; color: #5f5f5f;">
                                    云端服务：{{ state.bankEndpoint }}
                                </div>
                            </template>
                        </t-alert>
                        <div class="sk-btn-row" style="margin-bottom: 8px;">
                            <t-button size="small" theme="primary" variant="outline" block @click="panel.cloudPullConfig()">从云端拉取配置</t-button>
                            <t-button size="small" variant="outline" block @click="panel.cloudPushConfig()">同步配置到云端</t-button>
                        </div>
                        <div class="sk-btn-row" style="margin-bottom: 8px;">
                            <t-button size="small" theme="warning" variant="outline" block @click="panel.mergeGuestData()">合并游客数据到本账号</t-button>
                        </div>
                        <div class="sk-setting-row" style="margin-bottom: 8px;">
                            <span class="sk-setting-label">同步时包含 API Key（谨慎）</span>
                            <t-switch v-model="state.cloudIncludeKey" />
                        </div>
                        <div v-if="state.cloudStatusMsg" class="sk-status-detail" style="margin-bottom: 8px; font-size: 12px; color: #007aff;">{{ state.cloudStatusMsg }}</div>
                        <div class="sk-btn-row">
                            <t-button size="small" theme="danger" variant="outline" block @click="panel.cloudLogout()">退出登录（不再自动注册游客）</t-button>
                            <t-button size="small" theme="primary" variant="outline" block @click="panel.cloudSwitchAccount()">切换账号</t-button>
                        </div>
                    </template>

                    <!-- 未登录状态 -->
                    <template v-else>
                        <t-alert theme="info" class="sk-tcard" style="margin-bottom: 8px;">
                            <template #message>
                                <strong>云端账户</strong>
                                <div style="font-size: 12px; margin-top: 2px;">登录后可将刷课配置、AI 参数等同步到云端，在不同设备间同步使用。也可先用「退出登录（不再自动注册游客）」退出游客，再在此登录正式账号。</div>
                            </template>
                        </t-alert>
                        <!-- 正式账号登录表单（脚本侧直接登录，覆盖游客自动注册态） -->
                        <div class="sk-field" style="margin-top: 8px;">
                            <div class="sk-field-label">邮箱（正式账号）</div>
                            <t-input v-model="state.cloudEmail" size="small" placeholder="your@email.com" :clearable="true"></t-input>
                        </div>
                        <div class="sk-field" style="margin-top: 8px;">
                            <div class="sk-field-label">密码</div>
                            <t-input v-model="state.cloudPassword" size="small" type="password" placeholder="密码" :clearable="true" @enter="panel.cloudLogin()"></t-input>
                        </div>
                        <div class="sk-btn-row" style="margin-bottom: 8px;">
                            <t-button size="small" theme="primary" block @click="panel.cloudLogin()">登录正式账号</t-button>
                        </div>
                        <div class="sk-btn-row" style="margin-bottom: 8px;">
                            <t-button size="small" theme="primary" variant="outline" block @click="panel.cloudOpenLogin()">前往网页登录</t-button>
                            <t-button size="small" variant="outline" block @click="panel.cloudRegister()">前往网页注册</t-button>
                        </div>
                        <div v-if="state.cloudStatusMsg" class="sk-status-detail" style="font-size: 12px; margin-bottom: 8px; color: #007aff;">{{ state.cloudStatusMsg }}</div>
                        <t-link theme="primary" href="#" @click.prevent="panel.cloudOpenForgot()" style="font-size: 12px;">
                            忘记密码？
                        </t-link>
                    </template>

                    <!-- 云端 AI 答题（登录后可用云端余额答题，免本地 Key） -->
                    <t-card class="sk-tcard" style="margin-top: 8px;">
                        <template #title>云端 AI 答题</template>
                        <div v-if="state.cloudLoggedIn" class="sk-status-detail" style="font-size: 12px; margin-bottom: 8px;">
                            ✔ 已登录，云端 AI 可用（单次约 ¥0.01）。当前余额：¥{{ (state.cloudProfile && state.cloudProfile.balance != null ? state.cloudProfile.balance : 0).toFixed(2) }}
                        </div>
                        <div v-else class="sk-status-detail" style="font-size: 12px; margin-bottom: 8px; color: #ff9f0a;">
                            ⚠ 未登录云端账户，云端 AI 不可用。登录后即可使用云端余额 AI 答题（免本地 API Key）；也可在「设置-AI 答题设置」选择仅本地 Key 或自动模式。
                        </div>
                        <div class="sk-field">
                            <div class="sk-field-label">本系统访问 API Key（自动获取账户可用 Key）</div>
                            <t-select v-model="state.cloudApiKey" size="small" :popup-props="state.selectPopupProps" @change="panel.saveCloudApiKey()">
                                <t-option v-for="(sk, i) in state.sessionApiKeys" :key="'s' + i" :value="sk.key" :label="(sk.name || 'Key') + '（本会话）'"></t-option>
                                <t-option value="__custom__" label="自定义 / 手动输入"></t-option>
                            </t-select>
                            <div v-if="state.cloudApiKey === '__custom__'" class="sk-field-row" style="margin-top: 6px;">
                                <t-input v-model="state.cloudApiKeyCustom" :type="state.cloudApiKeyVisible ? 'text' : 'password'" placeholder="粘贴本系统 API Key" size="small" @change="panel.saveCloudApiKey()" />
                                <t-button size="small" variant="outline" @click="state.cloudApiKeyVisible = !state.cloudApiKeyVisible">
                                    {{ state.cloudApiKeyVisible ? '隐藏' : '显示' }}
                                </t-button>
                            </div>
                            <div class="sk-field-row" style="margin-top: 6px;">
                                <t-button size="small" @click="panel.createAccountApiKey()">新建 API Key</t-button>
                                <t-button size="small" variant="outline" @click="panel.loadAccountKeys()">刷新账户 Key</t-button>
                            </div>
                            <div v-if="state.cloudAvailableKeys && state.cloudAvailableKeys.length" style="margin-top: 6px; font-size: 12px; color: #8e8e93;">
                                <div v-for="k in state.cloudAvailableKeys" :key="k.id" class="sk-field-row" style="justify-content: space-between;">
                                    <span>{{ (k.name || ('Key#' + k.id)) }}：{{ k.api_key_masked || (k.api_key || '') }}</span>
                                    <t-button size="small" variant="text" @click="panel.deleteAccountApiKey(k.id)">删除</t-button>
                                </div>
                            </div>
                            <div style="font-size: 12px; margin-top: 4px; color: #8e8e93;">
                                该 Key 仅用于访问本系统云端（X-API-Key 鉴权，与登录态并存）；AI 服务商 Key 由云端后端 config.yaml 配置，前端不涉及。
                            </div>
                            <div class="sk-field" style="margin-top: 8px;">
                                <t-checkbox v-model="state.cloudGuestReport" @change="panel.saveCloudGuestReport()">游客上报学习进度（未登录云端也可上报，管理员统计用户/进度用）</t-checkbox>
                                <div style="font-size: 12px; color: #8e8e93; margin-top: 2px;">
                                    游客使用本机稳定标识（X-Guest-Id）上报，服务端需放行 POST /api/study/guest-report。
                                </div>
                            <div class="sk-field" style="margin-top: 8px;">
                                <t-checkbox v-model="state.cloudAutoGuestLogin" @change="panel.saveCloudAutoGuestLogin()">自动注册游客账号并登录云端（默认开）</t-checkbox>
                                <div style="font-size: 12px; color: #8e8e93; margin-top: 2px;">
                                    关闭后：点「退出登录」即退出游客，不再被自动注册，可前往网页登录自己的正式账号；再点「切换账号」恢复自动注册。
                                </div>
                            </div>
                            </div>
                        </div>
                        <div class="sk-btn-row">
                            <t-button size="small" theme="primary" variant="outline" block :disabled="!state.cloudLoggedIn" :loading="state.cloudAITesting" @click="panel.testCloudAI()">测试云端 AI（扣费一次）</t-button>
                        </div>
                        <t-alert v-if="state.cloudAITestResult" :theme="state.cloudAITestResult.ok ? 'success' : 'error'" class="sk-ai-alert">
                            <template #title>
                                <strong>{{ state.cloudAITestResult.ok ? '云端 AI 测试成功' : '云端 AI 测试失败' }}</strong>
                            </template>
                            <div v-if="state.cloudAITestResult.ok">答案: <strong class="sk-ans">{{ state.cloudAITestResult.answer }}</strong><span v-if="state.cloudAITestResult.cost != null">（消耗 ¥{{ state.cloudAITestResult.cost }}，余额 ¥{{ state.cloudAITestResult.balance }}）</span></div>
                            <div v-else>错误: {{ state.cloudAITestResult.error }}</div>
                            <div v-if="state.cloudAITestResult.time" class="sk-last-time">{{ state.cloudAITestResult.time }}</div>
                        </t-alert>
                    </t-card>
                </div>


                <!-- ============ 日志 Tab ============ -->
                <div v-show="state.activeTab === 'logs'">
                    <!-- 日志 -->
                    <t-card size="small" :bordered="true" class="sk-tcard">
                        <template #header>
                            <div class="sk-tcard-title">
                                <t-icon name="file-text" style="color:#8e8e93;" />日志
                                <t-badge :count="filteredLogs.length" :max-count="99" size="small" />
                            </div>
                        </template>
                        <div class="sk-logs-toolbar">
                            <t-input v-model="state.logSearch" placeholder="搜索日志..." size="small" clearable />
                            <t-select v-model="state.logLevel" size="small" :popup-props="state.selectPopupProps" style="width: 86px;">
                                <t-option value="all" label="全部"></t-option>
                                <t-option value="error" label="错误"></t-option>
                                <t-option value="warning" label="警告"></t-option>
                                <t-option value="success" label="成功"></t-option>
                                <t-option value="info" label="信息"></t-option>
                                <t-option value="debug" label="调试"></t-option>
                            </t-select>
                        </div>
                        <t-list v-if="filteredLogs.length > 0" class="sk-logs-list" :split="true">
                            <t-list-item v-for="(log, idx) in filteredLogs" :key="idx" class="sk-log-entry" :data-level="log.level" :title="log.ts ? formatDateTime(log.ts) : ''">
                                <span class="sk-log-icon"><t-icon :name="showLevelIcon(log.level)" /></span>
                                <span class="sk-log-time">{{ log.time }}</span>
                                <span class="sk-log-msg">{{ log.message }}</span>
                                <span v-if="log.count && log.count > 1" class="sk-log-count">×{{ log.count }}</span>
                            </t-list-item>
                        </t-list>
                        <t-empty v-else description="暂无日志" :image-style="{ width: '48px' }" />
                        <t-space size="small" class="sk-log-actions">
                            <t-button size="small" variant="text" @click="panel.clearLogs()">清空</t-button>
                            <t-button size="small" variant="text" @click="panel.exportLogs()">导出</t-button>
                        </t-space>
                    </t-card>
                </div>

                <!-- ============ 设置 Tab ============ -->
                <div v-show="state.activeTab === 'settings'">
                    <!-- 基础设置 -->
                    <t-collapse v-model="collapseBasic" class="sk-tcollapse">
                        <t-collapse-panel value="1" header="基础设置">
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">调试模式（详细日志）</span>
                                <t-switch v-model="state.debugMode" @change="panel.onDebugModeChange($event)" />
                            </div>
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">自动切换下一课程</span>
                                <t-switch v-model="state.autoNextCourse" @change="panel.onAutoNextChange($event)" />
                            </div>
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">⚡ 极速模式（直接接口完成课程）</span>
                                <t-switch v-model="state.turboMode" @change="panel.onTurboModeChange($event)" />
                            </div>
                            <div class="sk-setting-row" v-if="state.turboMode" style="padding-left: 24px; border-left: 2px solid var(--td-warning-color);">
                                <span class="sk-setting-label" style="color: var(--td-warning-color); font-size: 12px;">
                                    <svg width="14" height="14" viewBox="0 0 16 16" fill="currentColor" style="vertical-align: middle; margin-right: 4px;">
                                        <path d="M8 1a7 7 0 1 0 0 14A7 7 0 0 0 8 1zm0 12.5a5.5 5.5 0 1 1 0-11 5.5 5.5 0 0 1 0 11z"/>
                                        <path d="M7.25 5.25a.75.75 0 0 1 1.5 0v3a.75.75 0 0 1-1.5 0v-3zM8 11.5a1 1 0 1 1 0-2 1 1 0 0 1 0 2z"/>
                                    </svg>
                                    风险提示：极速模式直接调用接口完成，无真实播放过程，行为异常易被检测
                                </span>
                            </div>
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">Canvas微课完成后自动返回列表</span>
                                <t-switch v-model="state.canvasAutoBack" @change="panel.onCanvasAutoBackChange($event)" />
                            </div>
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">真实视频播放（2x 等待完成）</span>
                                <t-switch v-model="state.realVideoPlay" @change="panel.onRealVideoPlayChange($event)" />
                            </div>
                            <div class="sk-field-row">
                                <div class="sk-field">
                                    <div class="sk-field-label">检测间隔 (ms)</div>
                                    <t-input-number v-model="state.checkInterval" :min="500" :max="10000" :step="100" size="small" @change="panel.onBasicConfigChange()" />
                                </div>
                                <div class="sk-field">
                                    <div class="sk-field-label">翻页延迟 (ms)</div>
                                    <t-input-number v-model="state.pageTurnDelay" :min="0" :max="5000" :step="50" size="small" @change="panel.onBasicConfigChange()" />
                                </div>
                            </div>
                            <div class="sk-field-row">
                                <div class="sk-field">
                                    <div class="sk-field-label">完成阈值 (%)</div>
                                    <t-input-number v-model="state.progressThreshold" :min="50" :max="100" :step="1" size="small" @change="panel.onBasicConfigChange()" />
                                </div>
                                <div class="sk-field">
                                    <div class="sk-field-label">最大重试</div>
                                    <t-input-number v-model="state.maxRetryAttempts" :min="1" :max="20" :step="1" size="small" @change="panel.onBasicConfigChange()" />
                                </div>
                            </div>
                            <div class="sk-field">
                                <div class="sk-field-label">最小播放时间 (ms)</div>
                                <t-input-number v-model="state.minVideoPlayTime" :min="1000" :max="60000" :step="500" size="small" @change="panel.onBasicConfigChange()" />
                            </div>
                            <div class="sk-field-row">
                                <div class="sk-field">
                                    <div class="sk-field-label">真实播放倍速 (x)</div>
                                    <t-input-number v-model="state.videoPlaybackRate" :min="1" :max="8" :step="0.5" size="small" @change="panel.onBasicConfigChange()" />
                                </div>
                                <div class="sk-field">
                                    <div class="sk-field-label">防循环次数</div>
                                    <t-input-number v-model="state.courseRepeatLimit" :min="2" :max="20" :step="1" size="small" @change="panel.onBasicConfigChange()" />
                                </div>
                            </div>
                            <div class="sk-btn-row">
                                <t-button size="small" theme="primary" variant="outline" block @click="panel.saveBasicConfig()">保存</t-button>
                                <t-button size="small" variant="outline" block @click="panel.resetBasicConfig()">恢复默认</t-button>
                            </div>
                        </t-collapse-panel>
                    </t-collapse>

                    <!-- AI 设置 -->
                    <t-collapse v-model="collapseAI" class="sk-tcollapse">
                        <t-collapse-panel value="1" header="AI 答题设置">
                            <template #headerRightContent>
                                <t-tag size="small" :theme="badgeTheme(state.aiStatusBadge.type)" variant="light">{{ state.aiStatusBadge.text }}</t-tag>
                            </template>
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">启用 AI 答题</span>
                                <t-switch v-model="state.aiAnswerEnabled" @change="panel.onAIAnswerChange($event)" />
                            </div>
                            <div class="sk-field">
                                <div class="sk-field-label">AI 来源</div>
                                <t-select v-model="state.aiSource" size="small" :popup-props="state.selectPopupProps">
                                    <t-option value="auto" label="自动（云端优先，失败回退本地）"></t-option>
                                    <t-option value="cloud" label="仅云端 AI（需登录云端账户）"></t-option>
                                    <t-option value="local" label="仅本地 API Key"></t-option>
                                </t-select>
                                <div style="font-size: 12px; margin-top: 4px; color: #8e8e93;">
                                    <span v-if="state.aiSource === 'cloud' && !state.cloudLoggedIn" style="color: #ff9f0a;">⚠ 未登录云端账户，仅云端模式下 AI 答题将不可用</span>
                                    <span v-else-if="state.aiSource === 'cloud'">云端 AI 按次计费（每次约 ¥0.01），无需本地 Key</span>
                                    <span v-else-if="state.aiSource === 'auto' && state.cloudLoggedIn">已登录云端，AI 优先走云端（余额充足时），失败自动回退本地</span>
                                    <span v-else-if="state.aiSource === 'local'">仅使用下方本地 API Key</span>
                                    <span v-else>未登录云端，AI 走本地 API Key</span>
                                </div>
                            </div>
                            <div class="sk-field">
                                <div class="sk-field-label">API URL</div>
                                <t-input v-model="state.aiUrl" placeholder="http://api.mk.heymeta.cn" size="small" />
                            </div>
                            <div class="sk-field">
                                <div class="sk-field-label">API Key</div>
                                <div class="sk-field-row">
                                    <t-input v-model="state.aiKey" :type="state.aiKeyVisible ? 'text' : 'password'" placeholder="sk-..." size="small" />
                                    <t-button size="small" variant="outline" @click="state.aiKeyVisible = !state.aiKeyVisible">
                                        {{ state.aiKeyVisible ? '隐藏' : '显示' }}
                                    </t-button>
                                </div>
                            </div>
                            <div class="sk-field">
                                <div class="sk-field-label">模型</div>
                                <t-select v-model="state.aiModel" size="small" :popup-props="state.selectPopupProps">
                                    <t-option v-for="m in AI_MODEL_OPTIONS" :key="m.value" :value="m.value" :label="m.label"></t-option>
                                </t-select>
                            </div>
                            <div v-if="state.aiModel === '__custom__'" class="sk-field">
                                <div class="sk-field-label">自定义模型名</div>
                                <t-input v-model="state.aiModelCustom" placeholder="自定义模型" size="small" />
                            </div>
                            <div class="sk-field-row">
                                <div class="sk-field">
                                    <div class="sk-field-label">超时 (ms)</div>
                                    <t-input-number v-model="state.aiTimeout" :min="5000" :max="120000" :step="1000" size="small" />
                                </div>
                                <div class="sk-field">
                                    <div class="sk-field-label">重试</div>
                                    <t-input-number v-model="state.aiRetries" :min="0" :max="5" :step="1" size="small" />
                                </div>
                            </div>
                            <div class="sk-field-row">
                                <div class="sk-field">
                                    <div class="sk-field-label">Temperature</div>
                                    <t-input-number v-model="state.aiTemp" :min="0" :max="2" :step="0.1" size="small" />
                                </div>
                                <div class="sk-field">
                                    <div class="sk-field-label">Max Tokens</div>
                                    <t-input-number v-model="state.aiMaxTokens" :min="1" :max="2000" :step="1" size="small" />
                                </div>
                            </div>
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">使用默认 prompt</span>
                                <t-switch v-model="state.aiUseDefaultPrompt" />
                            </div>
                            <div v-if="!state.aiUseDefaultPrompt" class="sk-field">
                                <div class="sk-field-label">自定义 prompt</div>
                                <t-textarea v-model="state.aiPrompt" placeholder="使用 {question} {options} 占位符" size="small" :autosize="{ minRows: 3, maxRows: 8 }" />
                            </div>
                            <div class="sk-btn-row">
                                <t-button size="small" theme="primary" variant="outline" block @click="panel.saveAIConfig()">保存设置</t-button>
                                <t-button size="small" variant="outline" block @click="panel.resetAIConfig()">恢复默认</t-button>
                                <t-button size="small" variant="outline" block @click="panel.testAI()">测试 AI</t-button>
                            </div>
                            <t-alert v-if="state.aiLastResult" :theme="state.aiLastResult.ok ? 'success' : 'error'" class="sk-ai-alert">
                                <template #title>
                                    <strong><t-icon :name="state.aiLastResult.ok ? 'check-circle' : 'close-circle'" style="vertical-align:-1px;" /> {{ state.aiLastResult.ok ? 'AI 测试成功' : 'AI 测试失败' }}</strong>
                                </template>
                                <div v-if="state.aiLastResult.ok">答案: <strong class="sk-ans">{{ state.aiLastResult.ans }}</strong>（{{ state.aiLastResult.ms || 0 }}ms）</div>
                                <div v-else>错误: {{ state.aiLastResult.error }}</div>
                                <div v-if="state.aiLastResult.time" class="sk-last-time">{{ state.aiLastResult.time }}</div>
                            </t-alert>
                        </t-collapse-panel>
                    </t-collapse>

                    <!-- 云端题库 -->
                    <t-collapse v-model="collapseCloud" class="sk-tcollapse">
                        <t-collapse-panel value="1" header="云端题库">
                            <template #headerRightContent>
                                <t-tag size="small" :theme="badgeTheme(state.bankStatusBadge.type)" variant="light">{{ state.bankStatusBadge.text }}</t-tag>
                            </template>
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">启用云端题库</span>
                                <t-switch v-model="state.bankCloudEnabled" @change="panel.onBankCloudEnabledChange($event)" />
                            </div>
                            <div class="sk-field">
                                <div class="sk-field-label">云端端点</div>
                                <t-input v-model="state.bankEndpoint" placeholder="http://api.mk.heymeta.cn" size="small" @blur="panel.onBankEndpointChange()" />
                            </div>
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">自动上传 AI 答案</span>
                                <t-switch v-model="state.bankAutoUpload" @change="panel.onBankAutoUploadChange($event)" />
                            </div>
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">调用 AI 前查询云端</span>
                                <t-switch v-model="state.bankQueryBefore" @change="panel.onBankQueryBeforeChange($event)" />
                            </div>
                            <div class="sk-field">
                                <div class="sk-field-label">匹配策略</div>
                                <t-select v-model="state.bankStrategy" size="small" :popup-props="state.selectPopupProps" @change="panel.onBankStrategyChange($event)">
                                    <t-option value="both" label="精确 + 模糊"></t-option>
                                    <t-option value="exact" label="仅精确 hash"></t-option>
                                    <t-option value="prefix" label="仅模糊前缀"></t-option>
                                </t-select>
                            </div>
                            <div class="sk-btn-row">
                                <t-button size="small" variant="outline" block @click="panel.testBankConnection()">测试连接</t-button>
                                <t-button size="small" variant="outline" block @click="panel.uploadBankAll()">批量上传</t-button>
                                <t-button size="small" variant="outline" block @click="panel.resetCloudBankConfig()">恢复默认</t-button>
                            </div>
                        </t-collapse-panel>
                    </t-collapse>

                    <!-- 日志设置 -->
                    <t-collapse v-model="collapseLogs" class="sk-tcollapse">
                        <t-collapse-panel value="1" header="日志设置">
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">本地持久化日志（刷新保留）</span>
                                <t-switch v-model="state.logPersist" @change="panel.onLogPersistChange($event)" />
                            </div>
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">面板显示 debug 级别</span>
                                <t-switch v-model="state.showDebugLogs" @change="panel.onShowDebugLogsChange($event)" />
                            </div>
                            <div class="sk-field">
                                <div class="sk-field-label">最大保留条数</div>
                                <t-input-number v-model="state.logMax" :min="20" :max="500" :step="10" size="small" @change="panel.onLogMaxChange()" />
                            </div>
                            <div class="sk-field">
                                <div class="sk-field-label">当前日志 {{ state.logs.length }} 条</div>
                                <t-progress :percentage="Math.min(100, Math.round((state.logs.length / Math.max(1, state.logMax)) * 100))" size="small" :label="false" class="sk-progress" />
                            </div>
                            <div class="sk-btn-row">
                                <t-button size="small" variant="outline" block @click="panel.clearLogs()">清空日志</t-button>
                                <t-button size="small" variant="outline" block @click="panel.exportLogs()">导出日志</t-button>
                            </div>
                        </t-collapse-panel>
                    </t-collapse>

                    <!-- 本地缓存与数据 -->
                    <t-collapse v-model="collapseCache" class="sk-tcollapse">
                        <t-collapse-panel value="1" header="本地缓存与数据">
                            <div class="sk-hint" style="line-height:1.6;">清空题库、日志、统计、刷课记录、课程历史、身份快照等本地缓存。<br>保留：站点登录态、云端账户、面板设置。</div>
                            <div class="sk-btn-row">
                                <t-button size="small" theme="danger" variant="outline" block @click="panel.clearLocalCache()">清空本地缓存</t-button>
                            </div>
                        </t-collapse-panel>
                    </t-collapse>

                    <!-- 快捷键 -->
                    <t-collapse v-model="collapseShortcut" class="sk-tcollapse">
                        <t-collapse-panel value="1" header="快捷键">
                            <div class="sk-shortcut-grid">
                                <div v-for="s in shortcuts" :key="s.key" class="sk-shortcut-row">
                                    <span class="sk-key">{{ s.key }}</span>
                                    <span class="sk-shortcut-desc">{{ s.desc }}</span>
                                </div>
                            </div>
                            <div class="sk-hint">在输入框 / 文本域中按键时无效。</div>
                        </t-collapse-panel>
                    </t-collapse>

                    <!-- 版本与更新 -->
                    <t-collapse v-model="collapseVersion" class="sk-tcollapse">
                        <t-collapse-panel value="1" header="版本与更新">
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">当前版本</span>
                                <span style="font-weight:600;">{{ versionInfo.current }}<template v-if="versionInfo.channel && versionInfo.channel !== 'stable'"><span style="color:#007aff;">（{{ versionInfo.channel }} 渠道）</span></template></span>
                            </div>
                            <div v-if="versionInfo.minClientVersion" class="sk-hint" style="color:#86868b;">
                                强制升级阈值：{{ versionInfo.minClientVersion }}
                            </div>
                            <div v-if="versionInfo.reason" class="sk-hint" style="color:#86868b;">
                                {{ versionInfo.reason }}
                            </div>
                            <div class="sk-setting-row">
                                <span class="sk-setting-label">最新版本</span>
                                <span :style="{color: versionInfo.needUpdate ? '#ff9500' : '#34c759', fontWeight:600}">
                                    {{ versionInfo.latest || '未检查' }}
                                </span>
                            </div>
                            <div v-if="versionInfo.needUpdate && !versionInfo.force" class="sk-hint" style="color:#ff9500;">
                                发现新版本，建议更新
                            </div>
                            <div v-if="versionInfo.force" class="sk-hint" style="color:#ff3b30;font-weight:600;">
                                ⚠️ 强制更新：当前版本过低，必须升级
                            </div>
                            <div v-if="versionInfo.changelog" class="sk-hint" style="white-space:pre-wrap;max-height:80px;overflow-y:auto;">
                                更新说明：{{ versionInfo.changelog }}
                            </div>
                            <div v-if="versionInfo.error" class="sk-hint" style="color:#ff3b30;">
                                检查失败：{{ versionInfo.error }}
                            </div>
                            <div v-if="versionInfo.lastCheck" class="sk-hint">
                                上次检查：{{ versionInfo.lastCheck }}
                            </div>
                            <div class="sk-btn-row">
                                <t-button size="small" :loading="versionInfo.checking" @click="panel.checkVersion()">检查更新</t-button>
                                <t-button v-if="versionInfo.downloadUrl" size="small" variant="outline" @click="panel.openDownload()">下载新版</t-button>
                            </div>
                        </t-collapse-panel>
                    </t-collapse>
                </div>
            </div>
        </div>
        `;
    }

    ns.buildPanelApp = buildPanelApp;
    ns.installTDesign = installTDesign;
})();

/* ============================================================
 * 【生产内联结束】
 * ============================================================ */
















































    // ========== 控制面板 (Vue 3 + TDesign) ==========
    // 设计说明：
    //   1. 对外 API（updateStatus / addLog / updateProgress 等）完全保持兼容，内部改为更新 Vue reactive state
    //   2. 开发模式（__SHUAKE_DEV__ = true）：从 panel/ 目录加载文件，由 ShuaKePanelLoader 注入
    //   3. 生产模式：所有 panel 文件内联在此，直接使用 window.ShuaKePanel 命名空间
    //   4. CDN 降级：Vue/TDesign 未加载时自动回退到原有的纯 DOM 实现（保留所有逻辑）
    class ControlPanel {
        constructor() {
            // 【单例守卫】整个页面只允许存在一个面板实例：若已有实例（如 iframe 重复注入 / 多 Controller 触发），
            // 直接复用已有实例，不再重复创建 DOM 挂载点与 Vue App，避免多个 #shuake-panel 互相覆盖。
            try {
                if (typeof window !== 'undefined' && window.shuakePanelInstance &&
                    typeof window.shuakePanelInstance.updateStatus === 'function') {
                    return window.shuakePanelInstance;
                }
            } catch (_) {}
            this.panel = null;   // 挂载 DOM 根节点
            this._root = null;   // Vue App 根实例
            this._state = null;  // reactive state
            this._importInput = null; // 导入题库的隐藏 file input
            this._init();
        }

        _init() {
            // 根据可用库决定使用 Vue 模式还是降级到 DOM 模式
            if (Libs.hasVuePanel) {
                this._initVueMode();
            } else {
                // 降级：记录日志并静默使用原有 DOM 实现
                safeCall(() => {
                    try { Logger.debug('Vue/TDesign 未就绪，使用 DOM 降级模式'); } catch (_) {}
                });
                // 在降级模式下使用原有的 DOM 逻辑（如果已内联则使用，否则创建空实现）
                this._useDOMFallback();
            }
        }

        _initVueMode() {
            // 【诊断日志】在获取 Vue 引用前记录状态
            safeCall(() => {
                console.log('[DEBUG] _initVueMode 开始，Libs 状态:', {
                    'Libs.Vue': !!Libs.Vue,
                    'Libs._vue': !!Libs._vue,
                    'Libs.TDesign': !!Libs.TDesign,
                    'Libs._tdesign': !!Libs._tdesign,
                    'window.Vue': !!(typeof window !== 'undefined' && window.Vue),
                    'window.TDesign': !!(typeof window !== 'undefined' && window.TDesign),
                    '_sandboxVueRef': !!_sandboxVueRef,
                    '_sandboxTDRef': !!_sandboxTDRef
                });
            });
            
            const Vue = Libs.Vue;
            const TD = Libs.TDesign;
            
            // 【诊断日志】获取后立即检查
            safeCall(() => {
                console.log('[DEBUG] 从 Libs 获取引用后:', {
                    'const Vue': !!Vue,
                    'const TD': !!TD,
                    'Vue === Libs.Vue': Vue === Libs.Vue,
                    'Vue === _sandboxVueRef': Vue === _sandboxVueRef,
                    'Vue === window.Vue': Vue === (typeof window !== 'undefined' ? window.Vue : null)
                });
            });
            
            // 【关键修复】立即确保 window.Vue 和 window.TDesign 全局可用
            // TDesign UMD 组件在整个生命周期都可能访问全局 Vue
            if (typeof window !== 'undefined') {
                if (!window.Vue && _sandboxVueRef) {
                    window.Vue = _sandboxVueRef;
                    safeCall(() => Logger.debug('_initVueMode 入口恢复 window.Vue'));
                }
                if (!window.TDesign && _sandboxTDRef) {
                    window.TDesign = _sandboxTDRef;
                    safeCall(() => Logger.debug('_initVueMode 入口恢复 window.TDesign'));
                }
            }
            
            // 强化校验：必须是真的 Vue 3（含 ref/createApp/reactive）与可用的 TDesign，
            // 否则静默降级到 DOM 模式，避免 "Cannot read properties of undefined (reading 'ref')" 崩溃
            if (!Vue || typeof Vue.ref !== 'function' || typeof Vue.reactive !== 'function' || typeof Vue.createApp !== 'function') {
                safeCall(() => {
                    try { Logger.debug('Vue API 不完整（ref/reactive/createApp），使用 DOM 降级模式'); } catch (_) {}
                });
                this._useDOMFallback();
                return;
            }
            if (!TD || (typeof TD !== 'function' && !TD.default && typeof TD.install !== 'function')) {
                safeCall(() => {
                    try { Logger.debug('TDesign 不可用，使用 DOM 降级模式'); } catch (_) {}
                });
                this._useDOMFallback();
                return;
            }

            // 注入 TDesign CSS（如果尚未注入）
            try { TDesignLoader.ensureCSS(); } catch (_) {}

            // 注入面板自定义 CSS（如果尚未注入）
            if (!document.querySelector('style[data-shuake-panel-css]')) {
                const css = document.createElement('style');
                css.dataset.shuakePanelCss = '1';
                css.textContent = ShuaKePanelCSS || '';
                (document.head || document.documentElement).appendChild(css);
            }

            // 注入日志样式增强补丁 v2.48 - 让日志类型更显而易见
            if (!document.querySelector('style[data-shuake-log-patch]')) {
                const logPatch = document.createElement('style');
                logPatch.dataset.shuakeLogPatch = '1';
                logPatch.textContent = `
/* 日志样式增强 - 显而易见的日志类型 */
#shuake-panel .sk-log-entry {
    padding: 7px 10px !important;
    line-height: 1.5 !important;
    gap: 8px !important;
    border-radius: 6px !important;
    margin: 2px 0 !important;
    transition: background 0.15s ease !important;
    position: relative !important;
}
#shuake-panel .sk-log-entry:hover {
    background: rgba(0, 0, 0, 0.04) !important;
}
#shuake-panel .sk-log-icon {
    width: 18px !important;
    height: 18px !important;
    display: flex !important;
    align-items: center !important;
    justify-content: center !important;
    border-radius: 50% !important;
    opacity: 1 !important;
}
#shuake-panel .sk-log-icon .t-icon {
    font-size: 14px !important;
}
#shuake-panel .sk-log-time {
    font-family: ui-monospace, "SF Mono", monospace !important;
    font-variant-numeric: tabular-nums !important;
}
#shuake-panel .sk-log-count {
    border-radius: 8px !important;
    padding: 2px 6px !important;
    min-width: 18px !important;
    text-align: center !important;
    margin-left: 0 !important;
}
/* 错误 - 红色 */
#shuake-panel .sk-log-entry[data-level="error"] {
    background: rgba(255, 59, 48, 0.08) !important;
    border-left: 3px solid #ff3b30 !important;
}
#shuake-panel .sk-log-entry[data-level="error"] .sk-log-icon {
    background: rgba(255, 59, 48, 0.15) !important;
    color: #ff3b30 !important;
}
#shuake-panel .sk-log-entry[data-level="error"] .sk-log-msg {
    color: #d32f2f !important;
    font-weight: 500 !important;
}
/* 警告 - 橙色 */
#shuake-panel .sk-log-entry[data-level="warning"] {
    background: rgba(255, 149, 0, 0.08) !important;
    border-left: 3px solid #ff9500 !important;
}
#shuake-panel .sk-log-entry[data-level="warning"] .sk-log-icon {
    background: rgba(255, 149, 0, 0.15) !important;
    color: #ff9500 !important;
}
#shuake-panel .sk-log-entry[data-level="warning"] .sk-log-msg {
    color: #e65100 !important;
    font-weight: 500 !important;
}
/* 成功 - 绿色 */
#shuake-panel .sk-log-entry[data-level="success"] {
    background: rgba(52, 199, 89, 0.08) !important;
    border-left: 3px solid #34c759 !important;
}
#shuake-panel .sk-log-entry[data-level="success"] .sk-log-icon {
    background: rgba(52, 199, 89, 0.15) !important;
    color: #34c759 !important;
}
#shuake-panel .sk-log-entry[data-level="success"] .sk-log-msg {
    color: #2e7d32 !important;
}
/* 信息 - 蓝色 */
#shuake-panel .sk-log-entry[data-level="info"] {
    background: rgba(0, 122, 255, 0.06) !important;
    border-left: 3px solid #007aff !important;
}
#shuake-panel .sk-log-entry[data-level="info"] .sk-log-icon {
    background: rgba(0, 122, 255, 0.12) !important;
    color: #007aff !important;
}
/* 调试 - 灰色 */
#shuake-panel .sk-log-entry[data-level="debug"] {
    opacity: 0.75 !important;
}
#shuake-panel .sk-log-entry[data-level="debug"] .sk-log-icon {
    background: rgba(0, 0, 0, 0.08) !important;
    color: #86868b !important;
}
#shuake-panel .sk-log-entry[data-level="debug"] .sk-log-msg {
    color: #6e6e73 !important;
    font-size: 10px !important;
}
                `;
                (document.head || document.documentElement).appendChild(logPatch);
            }

            // 初始化 utils 和 store
            if (typeof ShuaKePanel === 'undefined' || !ShuaKePanel.utils) {
                safeCall(() => Logger.debug('ShuaKePanel.utils 未就绪，Vue 模式初始化跳过'));
                this._useDOMFallback();
                return;
            }

            const { createStore } = ShuaKePanel;
            if (typeof createStore !== 'function') {
                safeCall(() => Logger.debug('ShuaKePanel.createStore 未就绪，Vue 模式初始化跳过'));
                this._useDOMFallback();
                return;
            }

            // 创建响应式 state
            const state = createStore({ Vue, CONFIG, State, Statistics });

            // 应用持久化的面板 UI 状态（拖拽位置 / 最小化 / 显隐 / 标签页 / 折叠 / 筛选）
            try {
                this._panelState = (typeof PanelState !== 'undefined') ? PanelState.load() : null;
                if (this._panelState) {
                    const ps = this._panelState;
                    if (ps.activeTab) state.activeTab = ps.activeTab;
                    if (ps.minimized != null) state.minimized = !!ps.minimized;
                    if (ps.panelVisible != null) state.panelVisible = ps.panelVisible !== false;
                    if (ps.expanded) {
                        if (ps.expanded.course != null) state.expandedCourse = !!ps.expanded.course;
                        if (ps.expanded.cloud != null) state.expandedCloud = !!ps.expanded.cloud;
                        if (ps.expanded.last != null) state.expandedLast = !!ps.expanded.last;
                        if (ps.expanded.basic != null) state.expandedBasic = !!ps.expanded.basic;
                        if (ps.expanded.ai != null) state.expandedAI = !!ps.expanded.ai;
                        if (ps.expanded.logs != null) state.expandedLogs = !!ps.expanded.logs;
                        if (ps.expanded.shortcut != null) state.expandedShortcut = !!ps.expanded.shortcut;
                        if (ps.expanded.cache != null) state.expandedCache = !!ps.expanded.cache;
                        if (ps.expanded.version != null) state.expandedVersion = !!ps.expanded.version;
                    }
                    if (ps.logSearch != null) state.logSearch = ps.logSearch;
                    if (ps.logLevel != null) state.logLevel = ps.logLevel;
                    if (ps.bankFilter) {
                        if (ps.bankFilter.q != null) state.bankFilter.q = ps.bankFilter.q;
                        if (ps.bankFilter.type != null) state.bankFilter.type = ps.bankFilter.type;
                        if (ps.bankFilter.source != null) state.bankFilter.source = ps.bankFilter.source;
                    }
                }
            } catch (_) {}

            // 恢复云端账户登录态
            try {
                if (typeof this._refreshCloudState === 'function') this._refreshCloudState();
            } catch (_) {}

            // 构建 Vue App
            const { buildPanelApp, installTDesign } = ShuaKePanel;
            if (typeof buildPanelApp !== 'function') {
                safeCall(() => Logger.debug('ShuaKePanel.buildPanelApp 未就绪，Vue 模式初始化跳过'));
                this._useDOMFallback();
                return;
            }

            let app;
            try {
                // 最后一次防御检查：确保 Vue 完整可用（防止在 createApp 时访问 undefined）
                if (!Vue || !Vue.createApp || !Vue.ref || !Vue.reactive) {
                    const vueState = {
                        exists: !!Vue,
                        hasCreateApp: !!(Vue && Vue.createApp),
                        hasRef: !!(Vue && Vue.ref),
                        hasReactive: !!(Vue && Vue.reactive),
                        windowVue: !!(typeof window !== 'undefined' && window.Vue),
                        LibsVue: !!(Libs && Libs.Vue),
                        sandboxVueRef: !!_sandboxVueRef
                    };
                    safeCall(() => {
                        try { 
                            Logger.error('Vue API 校验失败，状态:', vueState);
                            console.error('[DEBUG] Vue 引用链:', {
                                'const Vue': Vue,
                                'Libs.Vue': Libs.Vue,
                                'Libs._vue': Libs._vue,
                                'window.Vue': window.Vue,
                                '_sandboxVueRef': _sandboxVueRef
                            });
                        } catch (_) {}
                    });
                    this._useDOMFallback();
                    return;
                }
                
                // 【诊断日志】在调用 buildPanelApp 前确认 Vue 引用
                safeCall(() => {
                    console.log('[DEBUG] 准备调用 buildPanelApp，参数状态:', {
                        'Vue': !!Vue,
                        'Vue.ref': typeof Vue.ref,
                        'Vue.createApp': typeof Vue.createApp,
                        'TD': !!TD,
                        'state': !!state,
                        'panel': !!this
                    });
                });
                
                // 【关键修复】强制确保 window.Vue 在整个 createApp/use/mount 流程中可用
                // TDesign UMD 的 install 函数和组件渲染时可能访问全局 window.Vue
                const needsRestore = (typeof window !== 'undefined' && !window.Vue);
                if (needsRestore && _sandboxVueRef) {
                    window.Vue = _sandboxVueRef;
                    safeCall(() => Logger.debug('临时恢复 window.Vue 供 TDesign 使用'));
                }
                
                app = Vue.createApp(buildPanelApp({ Vue, state, panel: this, TD }));
                installTDesign(app, TD);
            } catch (buildError) {
                safeCall(() => {
                    try { Logger.error(`面板构建失败，已降级：${buildError?.message || buildError}`); } catch (_) {}
                });
                this._useDOMFallback();
                return;
            }

            // 创建挂载点（body 未就绪时兜底挂到 documentElement，避免 document-start 阶段空引用）
            // 【单例守卫】若页面已存在 #shuake-panel（如先前降级占位面板或其他实例残留），
            // 直接复用该 DOM 作为 Vue 挂载点，保证全页面唯一面板。
            const _existingPanel = (typeof document !== 'undefined') ? document.getElementById('shuake-panel') : null;
            if (_existingPanel && _existingPanel !== this.panel) {
                this.panel = _existingPanel;
            } else {
                this.panel = document.createElement('div');
                this.panel.id = 'shuake-panel';
                (document.body || document.documentElement).appendChild(this.panel);
            }

            // 挂载异常（模板编译 / 组件解析失败等）不向外抛，避免拖垮整个脚本
            // 【关键修复：_Vue undefined】面板模板通过 Vue 运行时编译器生成 render 函数，
            // 编译产物形如 `const _Vue = Vue; const { createVNode } = _Vue;`，其中 `Vue` 在
            // 编译执行的【主世界全局作用域】解析（动态 script 注入的 Vue 库使用主世界 Function）。
            // 而 restoreMainVue() 在 TDesign 加载完成后已把主世界 Vue 删除/还原，仅沙箱 window.Vue
            // 保留 —— 导致 mount 时编译产物 _Vue 为 undefined，报
            // "Cannot destructure property 'createVNode' of '_Vue' as it is undefined"。
            // 因此 mount 前必须临时恢复主世界 unsafeWindow.Vue/TDesign，mount 完成后 finally 还原。
            const _mainRestore = (() => {
                try {
                    const pw = (typeof unsafeWindow !== 'undefined' && unsafeWindow) ? unsafeWindow : null;
                    if (!pw) return null;
                    const bak = {
                        pw,
                        vueHad: Object.prototype.hasOwnProperty.call(pw, 'Vue'),
                        vuePrev: pw.Vue,
                        tdHad: Object.prototype.hasOwnProperty.call(pw, 'TDesign'),
                        tdPrev: pw.TDesign
                    };
                    // 临时恢复主世界 Vue/TDesign（引用沙箱稳定副本），供编译产物作用域解析
                    if (_sandboxVueRef) {
                        try { Object.defineProperty(pw, 'Vue', { value: _sandboxVueRef, writable: false, configurable: true }); }
                        catch (_) { pw.Vue = _sandboxVueRef; }
                    }
                    if (_sandboxTDRef) {
                        try { Object.defineProperty(pw, 'TDesign', { value: _sandboxTDRef, writable: false, configurable: true }); }
                        catch (_) { pw.TDesign = _sandboxTDRef; }
                    }
                    return bak;
                } catch (_) { return null; }
            })();
            const _mainRestoreBack = () => {
                try {
                    if (!_mainRestore) return;
                    const { pw, vueHad, vuePrev, tdHad, tdPrev } = _mainRestore;
                    try {
                        if (vueHad) {
                            // 临时恢复时用 defineProperty(writable:false) 写入，直接赋值会因只读失败，
                            // 必须用 defineProperty 重新定义回原值（configurable:true 允许覆盖）
                            try { Object.defineProperty(pw, 'Vue', { value: vuePrev, writable: true, configurable: true }); }
                            catch (_) { try { pw.Vue = vuePrev; } catch (__) {} }
                        } else {
                            try { delete pw.Vue; } catch (_) { pw.Vue = undefined; }
                        }
                    } catch (_) {}
                    try {
                        if (tdHad) {
                            try { Object.defineProperty(pw, 'TDesign', { value: tdPrev, writable: true, configurable: true }); }
                            catch (_) { try { pw.TDesign = tdPrev; } catch (__) {} }
                        } else {
                            try { delete pw.TDesign; } catch (_) { pw.TDesign = undefined; }
                        }
                    } catch (_) {}
                } catch (_) {}
            };
            try {
                // 【关键修复】mount 前再次确保 window.Vue 可用（TDesign 组件渲染时需要）
                // 并使用 Object.defineProperty 锁定，防止页面代码在 mount 过程中清空
                if (typeof window !== 'undefined') {
                    if (!window.Vue && _sandboxVueRef) {
                        try {
                            Object.defineProperty(window, 'Vue', {
                                value: _sandboxVueRef,
                                writable: false,
                                configurable: true  // 允许之后删除（避免永久污染）
                            });
                            safeCall(() => Logger.debug('mount 前锁定 window.Vue'));
                        } catch (e) {
                            // 如果 defineProperty 失败（严格模式/冻结对象），降级到直接赋值
                            window.Vue = _sandboxVueRef;
                            safeCall(() => Logger.debug('mount 前恢复 window.Vue (无法锁定)'));
                        }
                    }
                    if (!window.TDesign && _sandboxTDRef) {
                        try {
                            Object.defineProperty(window, 'TDesign', {
                                value: _sandboxTDRef,
                                writable: false,
                                configurable: true
                            });
                            safeCall(() => Logger.debug('mount 前锁定 window.TDesign'));
                        } catch (e) {
                            window.TDesign = _sandboxTDRef;
                            safeCall(() => Logger.debug('mount 前恢复 window.TDesign (无法锁定)'));
                        }
                    }
                }
                
                app.mount(this.panel);

                // 【开始刷课才运行】挂载后同步按钮初始状态（与恢复后的 State.isRunning 一致）
                try { if (this._state) this._state.running = State.isRunning; } catch (_) {}
                
                // 挂载成功后打印调试信息
                safeCall(() => {
                    Logger.debug('面板挂载成功', {
                        hasWindowVue: !!(typeof window !== 'undefined' && window.Vue),
                        hasWindowTD: !!(typeof window !== 'undefined' && window.TDesign),
                        hasSandboxVueRef: !!_sandboxVueRef,
                        hasSandboxTDRef: !!_sandboxTDRef
                    });
                });
            } catch (mountError) {
                safeCall(() => {
                    try { 
                        Logger.error(`面板挂载异常，已降级：${mountError?.message || mountError}`);
                        Logger.debug('挂载失败时的状态:', {
                            windowVue: !!(typeof window !== 'undefined' && window.Vue),
                            windowTD: !!(typeof window !== 'undefined' && window.TDesign),
                            sandboxVueRef: !!_sandboxVueRef,
                            sandboxTDRef: !!_sandboxTDRef,
                            LibsVue: !!(Libs && Libs.Vue),
                            LibsTD: !!(Libs && Libs.TDesign)
                        });
                    } catch (_) {}
                });
                try { app.unmount(); } catch (_) {}
                try { this.panel.remove(); } catch (_) {}
                this.panel = null;
                this._useDOMFallback();
                return;
            } finally {
                // 无论 mount 成功或失败，都还原主世界 Vue/TDesign（避免污染宿主页全局）
                _mainRestoreBack();
            }

            this._state = state;
            this._root = app;

            // 【设置回显】挂载后统一将 CONFIG 中的全部设置项同步到面板 state，
            // 确保"设置"tab 各项开关 / 输入框 / 下拉框显示的是持久化后的实际配置，
            // 而非 buildPanelApp 创建时（可能早于 ConfigManager.load 完成）的初始快照。
            try { this.refreshSettingsAll(); } catch (_) {}

            // 应用持久化的面板位置 / 最小化 / 显示状态到 DOM
            try {
                if (this._panelState && this.panel) {
                    if (this._panelState.pos && typeof this._panelState.pos.left === 'number') {
                        // 【拖拽修复】用 important 覆盖样式表 top/right !important，否则持久化位置恢复无效
                        this.panel.style.setProperty('left', `${Math.max(0, this._panelState.pos.left)}px`, 'important');
                        this.panel.style.setProperty('top', `${Math.max(0, this._panelState.pos.top)}px`, 'important');
                        this.panel.style.setProperty('right', 'auto', 'important');
                    }
                    if (state.minimized) this.panel.classList.add('sk-minimized');
                    if (!state.panelVisible) this.panel.style.display = 'none';
                }
                // 面板隐藏时同步悬浮恢复按钮
                this._syncFloatFav();
            } catch (_) {}

            // 面板 UI 状态变更自动持久化（防抖，避免输入筛选词时频繁写存储）
            try {
                const saveSoon = () => {
                    if (this._panelStateTimer) return;
                    this._panelStateTimer = setTimeout(() => {
                        this._panelStateTimer = null;
                        this._savePanelState();
                    }, 400);
                };
                const watchKeys = ['activeTab', 'minimized', 'panelVisible',
                    'expandedCourse', 'expandedCloud', 'expandedLast', 'expandedBasic',
                    'expandedAI', 'expandedLogs', 'expandedShortcut', 'expandedCache', 'expandedVersion',
                    'logSearch', 'logLevel', 'bankFilter'];
                if (typeof Vue.watch === 'function') {
                    Vue.watch(
                        () => watchKeys.map((k) => JSON.stringify(state[k])).join('\u0001'),
                        saveSoon
                    );
                    // 面板显隐变化时立即同步悬浮恢复按钮（不经防抖）
                    Vue.watch(() => state.panelVisible, () => { try { this._syncFloatFav(); } catch (_) {} });
                }
            } catch (_) {}

            safeCall(() => {
                try { Logger.info(`面板已初始化（Vue 3 + TDesign mode）`); } catch (_) {}
            });
            // 面板挂载后同步云端登录态（GM 持久化恢复，防止切换/刷新丢失登录）与题库/云端数据
            try { if (typeof this._refreshCloudState === 'function') this._refreshCloudState(); } catch (_) {}
            try { if (typeof this.loadAccountKeys === 'function') this.loadAccountKeys(); } catch (_) {}
            try { if (typeof this.refreshBankPanel === 'function') this.refreshBankPanel(); } catch (_) {}
            try { if (typeof this.refreshQuestionList === 'function') this.refreshQuestionList(); } catch (_) {}
        }

        // 保存当前面板 UI 状态到存储
        _savePanelState() {
            try {
                const s = this._state;
                if (!s) return;
                const ps = {
                    pos: this._panelPos || null,
                    minimized: !!s.minimized,
                    panelVisible: s.panelVisible !== false,
                    activeTab: s.activeTab || 'main',
                    expanded: {
                        course: !!s.expandedCourse,
                        cloud: !!s.expandedCloud,
                        last: !!s.expandedLast,
                        basic: !!s.expandedBasic,
                        ai: !!s.expandedAI,
                        logs: !!s.expandedLogs,
                        shortcut: !!s.expandedShortcut,
                        cache: !!s.expandedCache,
                        version: !!s.expandedVersion
                    },
                    logSearch: s.logSearch || '',
                    logLevel: s.logLevel || 'all',
                    bankFilter: {
                        q: (s.bankFilter && s.bankFilter.q) || '',
                        type: (s.bankFilter && s.bankFilter.type) || 'all',
                        source: (s.bankFilter && s.bankFilter.source) || 'all'
                    }
                };
                if (typeof PanelState !== 'undefined') PanelState.save(ps);
            } catch (_) {}
        }

        // 拖拽结束时由面板组件回调，记录最终位置并持久化
        persistPosition(left, top) {
            try {
                const l = Number(left);
                const t = Number(top);
                if (!isNaN(l) && !isNaN(t) && l >= 0 && t >= 0) {
                    this._panelPos = { left: Math.round(l), top: Math.round(t) };
                    this._savePanelState();
                }
            } catch (_) {}
        }

        // 创建隐藏面板时的悬浮恢复按钮（fav 组件），仅创建一次
        _ensureFloatFav() {
            try {
                if (this._floatFav) return this._floatFav;
                const btn = document.createElement('div');
                btn.id = 'shuake-fav-float';
                btn.title = '展开面板 (K)';
                btn.innerHTML = '★';
                // 【fav 拖拽】悬浮按钮支持独立拖动（按住拖动移动位置；未拖动松开 = 恢复面板）
                btn.addEventListener('mousedown', (e) => {
                    if (e.button !== 0) return;
                    const startX = e.clientX, startY = e.clientY;
                    const rect = btn.getBoundingClientRect();
                    let moved = false;
                    const onMove = (ev) => {
                        const dx = ev.clientX - startX, dy = ev.clientY - startY;
                        if (!moved && (Math.abs(dx) + Math.abs(dy)) > 4) moved = true;
                        if (!moved) return;
                        const _vw = window.innerWidth || 0, _vh = window.innerHeight || 0;
                        const _L = Math.max(0, Math.min(ev.clientX - (startX - rect.left), _vw - 36));
                        const _T = Math.max(0, Math.min(ev.clientY - (startY - rect.top), _vh - 36));
                        btn.style.setProperty('left', `${_L}px`, 'important');
                        btn.style.setProperty('top', `${_T}px`, 'important');
                        btn.style.setProperty('right', 'auto', 'important');
                    };
                    const onUp = () => {
                        document.removeEventListener('mousemove', onMove);
                        document.removeEventListener('mouseup', onUp);
                        if (!moved) { try { this.toggleVisible(); } catch (_) {} }
                    };
                    document.addEventListener('mousemove', onMove);
                    document.addEventListener('mouseup', onUp);
                    if (e.preventDefault) e.preventDefault();
                    if (e.stopPropagation) e.stopPropagation();
                });
                // 初始隐藏（样式表 display:flex !important 会压过普通内联，必须用 important 覆盖）
                btn.style.setProperty('display', 'none', 'important');
                (document.body || document.documentElement).appendChild(btn);
                this._floatFav = btn;
                return btn;
            } catch (_) { return null; }
        }

        // 同步悬浮恢复按钮：面板隐藏时显示（跟随面板最后位置），显示时隐藏
        _syncFloatFav() {
            try {
                const btn = this._ensureFloatFav();
                if (!btn) return;
                // 优先用响应式状态判断；状态缺失（DOM 降级模式 _state===null）时，
                // 退化为从面板 DOM 的 display 推断——保证"隐藏面板→显示 ★ 恢复按钮"在降级下也成立。
                let hidden = !!(this._state && this._state.panelVisible === false);
                if (!this._state && this.panel) {
                    hidden = this.panel.style.display === 'none';
                }
                // 必须用 important 覆盖样式表的 display:flex !important，否则隐藏失效（★ 恒显示）
                btn.style.setProperty('display', hidden ? 'flex' : 'none', 'important');
                if (hidden && this.panel) {
                    const left = this.panel.style.left;
                    const top = this.panel.style.top;
                    // 【拖拽修复】用 important 覆盖样式表 top/right !important，否则跟随面板位置失效
                    if (left) btn.style.setProperty('left', left, 'important');
                    if (top) btn.style.setProperty('top', top, 'important');
                    if (left || top) btn.style.setProperty('right', 'auto', 'important');
                }
            } catch (_) {}
        }

        // 降级到原有 DOM 实现（当 Vue/TDesign 不可用时）
        _useDOMFallback() {
            try {
                // 调用原有的 DOM 面板逻辑（如果有内联的降级实现）
                if (typeof this._initDOMFallback === 'function') {
                    this._initDOMFallback();
                } else {
                    // 【单例守卫】若页面已存在 #shuake-panel（如其他实例/降级已创建），直接复用，
                    // 不再重复创建 DOM，保证全页面唯一面板。
                    const existing = (typeof document !== 'undefined') ? document.getElementById('shuake-panel') : null;
                    if (existing && existing !== this.panel) {
                        this.panel = existing;
                        return;
                    }
                    // 最基本的降级：渲染一个可见的占位面板（Vue/TDesign 恢复后自动切换为完整面板），
                    // 支持 K 键/头部切换显隐；隐藏时显示 ★ 恢复按钮（_syncFloatFav 用 DOM display 推断）。
                    this.panel = document.createElement('div');
                    this.panel.id = 'shuake-panel';
                    this.panel.style.cssText = 'position:fixed;top:20px;right:20px;z-index:999999;background:rgba(255,255,255,0.9);padding:12px;border-radius:8px;display:block;font-family:-apple-system,sans-serif;font-size:12px;color:#333;';
                    this.panel.textContent = '面板加载失败（Vue/TDesign 不可用），按 K 或点击 ★ 可显隐';
                    (document.body || document.documentElement).appendChild(this.panel);
                    safeCall(() => Logger.warning('面板降级模式：Vue/TDesign 未加载'));
                }
                // 降级下同样同步 ★ 恢复按钮（面板可见→fav 隐藏；被隐藏→fav 显示）
                try { this._syncFloatFav(); } catch (_) {}
            } catch (e) {
                safeCall(() => Logger.debug(`DOM 降级初始化异常: ${e.message}`));
            }
        }

        // ============================================================
        // 公开 API（与旧版 ControlPanel 完全兼容，驱动 Vue state 更新）
        // ============================================================

        updateStatus(text, className = '') {
            try {
                if (this._state) {
                    this._state.statusText = text == null ? '' : String(text);
                    this._state.statusClass = className || '';
                }
            } catch (_) {}
        }

        updateProgress(percent) {
            try {
                const p = Math.max(0, Math.min(100, Number(percent) || 0));
                if (this._state) {
                    this._state.progress = p;
                }
            } catch (_) {}
        }

        updateStats(stats) {
            try {
                if (!stats || typeof stats !== 'object') return;
                if (this._state) {
                    if (stats.duration !== undefined)    this._state.stats.duration = String(stats.duration);
                    if (stats.coursesCompleted !== undefined) this._state.stats.coursesCompleted = Number(stats.coursesCompleted);
                    if (stats.pagesViewed !== undefined) this._state.stats.pagesViewed = Number(stats.pagesViewed);
                    if (stats.errors !== undefined)      this._state.stats.errors = Number(stats.errors);
                    if (stats.lastErrorTime !== undefined) this._state.stats.lastErrorTime = stats.lastErrorTime;
                }
            } catch (_) {}
        }

        updateProjectInfo(info) {
            try {
                if (this._state) {
                    this._state.projectInfo = info || null;
                }
            } catch (_) {}
        }

        toggle() {
            try {
                if (this._state) {
                    this._state.minimized = !this._state.minimized;
                    if (this.panel) {
                        this.panel.classList.toggle('sk-minimized', this._state.minimized);
                    }
                } else if (this.panel) {
                    this.panel.classList.toggle('minimized');
                }
            } catch (_) {}
        }

        toggleMinimize() {
            this.toggle();
        }

        toggleVisible() {
            if (this.panel) {
                const visible = this.panel.style.display !== 'none';
                const next = !visible;
                this.panel.style.display = next ? '' : 'none';
                // 同步面板状态（切换显示图标）
                try {
                    if (this._state) this._state.panelVisible = next;
                } catch (_) {}
                this._syncFloatFav();
            }
        }

        start() {
            try {
                State.isRunning = true;
                State.isPaused = false;
                if (this._state) this._state.running = true;
                this.updateStatus('运行中', '');
                try { Logger.info('开始刷课'); } catch (_) {}
                // 【持久化】开始状态写入 GM，防止页面更新/刷新丢失
                try { gmWriteJSON('shuake_run_state', { isRunning: true, isPaused: false }); } catch (_) {}
            } catch (_) {}
        }

        togglePause() {
            try {
                State.isPaused = !State.isPaused;
                // 【继续】从暂停/停止恢复运行时，必须把 isRunning 置回 true，
                // 否则主循环会因 isRunning=false 一直短路不执行。
                if (!State.isPaused) State.isRunning = true;
                if (this._state) this._state.running = State.isRunning;
                this.updateStatus(State.isPaused ? '已暂停' : '运行中', State.isPaused ? 'paused' : '');
                // 【持久化】暂停/继续状态写入 GM，防止页面更新/刷新丢失按钮设置
                try { gmWriteJSON('shuake_run_state', { isPaused: State.isPaused, isRunning: State.isRunning }); } catch (_) {}
            } catch (_) {}
        }

        stop() {
            try {
                State.isRunning = false;
                State.isExamPage = false;
                State.aiProcessing = false;
                // 【刷课上报】用户手动停止：本课已开始则上报一次 running（中断记录，登录云端才生效）
                try { if (State.studyStartedAt) StudyReporter.report('running'); } catch (_) {}
                // 手动停止：停止 60s 心跳（不再维持"正在刷课"状态）
                try { StudyReporter.stopHeartbeat(); } catch (_) {}
                if (this._state) this._state.running = false;
                this.updateStatus('已停止', 'error');
                // 【持久化】停止状态写入 GM，防止页面更新/刷新丢失按钮设置
                try { gmWriteJSON('shuake_run_state', { isRunning: false, isPaused: true }); } catch (_) {}
            } catch (_) {}
        }

        addLog(entry) {
            try {
                const time = (entry && entry.time) ? String(entry.time) : new Date().toLocaleTimeString();
                const msg = (entry && entry.message != null) ? String(entry.message) : '';
                const level = (entry && entry.level || 'info').toLowerCase();

                // 面板显示 debug 开关（关闭时不进面板，console 仍输出）
                if (level === 'debug' && this._state && this._state.showDebugLogs === false) {
                    return;
                }

                if (this._state) {
                    const icons = { error: '✗', warning: '⚠', success: '✓', info: 'ℹ', debug: '·' };
                    const themes = { error: 'danger', warning: 'warning', success: 'success', info: 'primary', debug: 'default' };
                    const log = {
                        time,
                        ts: (entry && entry.ts) || Date.now(),
                        message: msg,
                        level,
                        icon: icons[level] || '·',
                        theme: themes[level] || 'default',
                        count: (entry && entry.count) || 1
                    };
                    this._state.logs.unshift(log);
                    // 动态限制条数（可配置 logMax）
                    const maxLogs = (this._state.logMax && this._state.logMax > 0) ? this._state.logMax : 100;
                    if (this._state.logs.length > maxLogs) {
                        this._state.logs.splice(maxLogs, this._state.logs.length - maxLogs);
                    }
                }

                // error/warning 级别触发 Toast
                if (level === 'error' || level === 'warning') {
                    try { ShuaKeUI.toast(msg, level === 'error' ? 'danger' : 'warning', level === 'error' ? 5000 : 4000); } catch (_) {}
                }
            } catch (_) {}
        }

        updateCourseInfo(info) {
            try {
                if (!info || typeof info !== 'object') return;
                if (this._state) {
                    this._state.courseInfo = {
                        name: info.name || '未知课程',
                        totalPage: info.totalPage || '-',
                        finishedPage: info.finishedPage || 0,
                        totalTime: info.totalTime || '-',
                        progress: info.progress !== undefined ? String(info.progress) : '-'
                    };
                }
            } catch (_) {}
        }

        // ============================================================
        // 刷新方法（用于面板内部的"刷新"按钮）
        // ============================================================

        refreshAll() {
            try {
                if (this._state) {
                    // 恢复云端登录态（GM 持久化）+ 账户 Key 列表（登录后切换/刷新不丢失）
                    try { if (typeof this._refreshCloudState === 'function') this._refreshCloudState(); } catch (_) {}
                    try { if (typeof this.loadAccountKeys === 'function') this.loadAccountKeys(); } catch (_) {}
                    // 刷新题库统计
                    this.refreshBankPanel();
                    // 统一刷新"设置"tab 下全部设置项（基础 / AI / 云端 / 日志）
                    this.refreshSettingsAll();
                    // 刷新题目列表
                    this.refreshQuestionList();
                    // 后台重新拉取课程/分类/考试（成功自动写缓存；失败回退缓存）
                    try {
                        if (typeof ProjectInfo !== 'undefined' && typeof ProjectInfo.fetchDetails === 'function') {
                            ProjectInfo.fetchDetails().then(() => { try { this.refreshCoursePanel(); } catch (_) {} }).catch(() => {});
                        }
                        if (typeof CategoryInfo !== 'undefined' && typeof CategoryInfo.fetchDetails === 'function') {
                            CategoryInfo.fetchDetails().then(() => { try { this.refreshCoursePanel(); } catch (_) {} }).catch(() => {});
                        }
                        if (typeof ExamManager !== 'undefined' && typeof ExamManager.fetchList === 'function') {
                            ExamManager.fetchList().then(() => { try { this.refreshCoursePanel(); } catch (_) {} }).catch(() => {});
                        }
                    } catch (_) {}
                    // 刷新课程/考试面板（先用现有内存/缓存数据）
                    this.refreshCoursePanel();
                    // 刷新统计
                    this.refreshStats();
                }
                safeCall(() => { ShuaKeUI.toast('面板已刷新', 'success', 1500); });
            } catch (_) {}
        }

        refreshBasicPanel() {
            try {
                if (!this._state) return;
                const cfg = CONFIG || {};
                this._state.debugMode = !!(cfg.debugMode);
                this._state.autoNextCourse = !!(cfg.autoNextCourse);
                this._state.turboMode = !!(cfg.turboMode);
                this._state.canvasAutoBack = cfg.canvasAutoBack === true;
                this._state.realVideoPlay = cfg.realVideoPlay === true;
                this._state.autoAdvanceEnabled = cfg.autoAdvanceEnabled !== false;
                this._state.checkInterval = cfg.checkInterval ?? 1200;
                this._state.pageTurnDelay = cfg.pageTurnDelay ?? 500;
                this._state.progressThreshold = Math.round((cfg.progressThreshold ?? 0.9) * 100);
                this._state.maxRetryAttempts = cfg.maxRetryAttempts ?? 5;
                this._state.minVideoPlayTime = cfg.minVideoPlayTime ?? 5000;
                this._state.videoPlaybackRate = cfg.videoPlaybackRate > 0 ? cfg.videoPlaybackRate : 2;
                this._state.courseRepeatLimit = cfg.courseRepeatLimit > 0 ? cfg.courseRepeatLimit : 3;
                this._state.debugBadgeVisible = !!(cfg.debugMode);
            } catch (_) {}
        }

        // 刷新日志设置到面板 state（回显）
        refreshLogPanel() {
            try {
                if (!this._state) return;
                const cfg = CONFIG || {};
                this._state.logPersist = cfg.logPersist !== false;
                this._state.showDebugLogs = cfg.showDebugLogs !== false;
                this._state.logMax = Math.max(20, Math.min(500, Number(cfg.logMax) || 100));
            } catch (_) {}
        }

        // 刷新云端题库设置到面板 state（回显）
        refreshCloudBankPanel() {
            try {
                if (!this._state) return;
                const cb = (CONFIG || {}).cloudBank || {};
                this._state.bankCloudEnabled = !!(cb.enabled);
                this._state.bankEndpoint = cb.endpoint || '';
                this._state.bankAutoUpload = !!(cb.autoUpload);
                this._state.bankQueryBefore = !!(cb.queryBeforeAI);
                this._state.bankStrategy = cb.matchStrategy || 'both';
            } catch (_) {}
        }

        // 统一刷新"设置"tab 下所有设置项（基础 / AI / 云端 / 日志），
        // 保证面板回显与 CONFIG 完全一致（用于面板挂载后、refreshAll、重置后）。
        refreshSettingsAll() {
            try {
                this.refreshBasicPanel();
                this.refreshAIConfigPanel();
                this.refreshCloudBankPanel();
                this.refreshLogPanel();
            } catch (_) {}
        }

        refreshAIConfigPanel() {
            try {
                if (!this._state) return;
                const cfg = (CONFIG || {}).aiConfig || {};
                const known = ['qwen-plus', 'qwen-turbo', 'qwen-max', 'gpt-4o-mini', 'gpt-4o'];
                const modelVal = cfg.model || 'qwen-plus';
                const isCustom = !known.includes(modelVal);
                this._state.aiAnswerEnabled = CONFIG.enableAIAnswer !== false;
                this._state.aiUrl = cfg.apiUrl || '';
                this._state.aiKey = cfg.apiKey || '';
                this._state.aiModel = isCustom ? '__custom__' : modelVal;
                this._state.aiModelCustom = isCustom ? (cfg.model || '') : '';
                this._state.aiTimeout = cfg.timeout || 30000;
                this._state.aiRetries = cfg.maxRetries != null ? cfg.maxRetries : 2;
                this._state.aiTemp = cfg.temperature != null ? cfg.temperature : 0.1;
                this._state.aiMaxTokens = cfg.maxTokens || 50;
                this._state.aiUseDefaultPrompt = cfg.useDefaultPrompt !== false;
                this._state.aiPrompt = cfg.systemPrompt || '';
                const savedCloudKey = (CONFIG.cloudBank && CONFIG.cloudBank.apiKey) || '';
                this._state.cloudApiKey = savedCloudKey;
                this._state.cloudApiKeyCustom = savedCloudKey;
                this._state.cloudGuestReport = !(CONFIG.cloudBank && CONFIG.cloudBank.guestReport === false);
                this._state.cloudAutoGuestLogin = !(CONFIG.cloudBank && CONFIG.cloudBank.autoGuestLogin === false);
                this._state.aiSource = cfg.source || 'auto';
                // 状态徽章（考虑 AI 来源：云端模式以登录态判定，本地模式以 Key 判定，auto 取任一可用）
                const hasConfig = !!(cfg.apiUrl && cfg.apiKey);
                const enabled = !!CONFIG.enableAIAnswer;
                const source = cfg.source || 'auto';
                const cloudReady = (typeof CloudAI !== 'undefined') && CloudAI.isAvailable();
                if (!enabled) {
                    this._state.aiStatusBadge = { type: 'off', text: '已禁用' };
                } else if (source === 'cloud') {
                    this._state.aiStatusBadge = cloudReady
                        ? { type: 'success', text: '云端模式已就绪' }
                        : { type: 'error', text: '云端模式未登录' };
                } else if (source === 'auto') {
                    this._state.aiStatusBadge = (hasConfig || cloudReady)
                        ? { type: 'success', text: '自动模式 / ' + (cfg.model || (cloudReady ? '云端' : '-')) }
                        : { type: 'error', text: '未配置' };
                } else if (!hasConfig) {
                    this._state.aiStatusBadge = { type: 'error', text: '未配置' };
                } else {
                    this._state.aiStatusBadge = { type: 'success', text: `已启用 / ${cfg.model || '-'}` };
                }
            } catch (_) {}
        }

        // 面板 tab 切换：切换到对应 tab 时刷新该 tab 数据（题库 / 云端 / 课程 / 概览 / 设置）
        onTabChange(val) {
            try {
                if (!this._state) return;
                if (val === 'bank') {
                    // 题库：刷新统计 + 问题列表（答题过程中命中会实时变化）
                    try { if (typeof this.refreshBankPanel === 'function') this.refreshBankPanel(); } catch (_) {}
                    try { if (typeof this.refreshQuestionList === 'function') this.refreshQuestionList(); } catch (_) {}
                } else if (val === 'cloud') {
                    // 云端：刷新登录态（含 GM 持久化恢复）+ 账户 API Key 列表
                    try { if (typeof this._refreshCloudState === 'function') this._refreshCloudState(); } catch (_) {}
                    try { if (typeof this.loadAccountKeys === 'function') this.loadAccountKeys(); } catch (_) {}
                    try { if (typeof this.refreshBankPanel === 'function') this.refreshBankPanel(); } catch (_) {}
                } else if (val === 'course') {
                    try { if (typeof this.refreshCoursePanel === 'function') this.refreshCoursePanel(); } catch (_) {}
                } else if (val === 'main') {
                    try { if (typeof this.refreshMainStats === 'function') this.refreshMainStats(); } catch (_) {}
                    try { if (typeof this.updateStats === 'function') this.updateStats(); } catch (_) {}
                } else if (val === 'settings') {
                    try { if (typeof this.refreshAIConfigPanel === 'function') this.refreshAIConfigPanel(); } catch (_) {}
                    try { if (typeof this.refreshCloudBankPanel === 'function') this.refreshCloudBankPanel(); } catch (_) {}
                }
            } catch (_) {}
        }

        refreshBankPanel() {
            try {
                if (!this._state) return;
                const stats = (typeof QuestionBank !== 'undefined' && QuestionBank.stats) ? QuestionBank.stats : {};
                const count = (typeof QuestionBank !== 'undefined' && typeof QuestionBank.count === 'function') ? QuestionBank.count() : 0;
                const verified = (typeof QuestionBank !== 'undefined' && typeof QuestionBank.all === 'function')
                    ? QuestionBank.all().filter((r) => r && r.verified).length : 0;
                const totalHits = (stats.localHits || 0) + (stats.cloudHits || 0) + (stats.aiHits || 0);
                const rate = count > 0 ? Math.round((totalHits / count) * 100) : 0;
                this._state.bankLocal = count;
                this._state.bankVerified = verified;
                this._state.bankHits = totalHits;
                this._state.bankLocalHits = stats.localHits || 0;
                this._state.bankCloud = stats.cloudHits || 0;
                this._state.bankAi = stats.aiHits || 0;
                this._state.bankRate = rate;
                this._state.bankCacheCount = stats.cacheHits || 0;
                this._state.bankAICount = stats.aiHits || 0;
                // 答题结果统计（持久化 answerStats）
                const ans = (typeof QuestionBank !== 'undefined' && QuestionBank.answerStats) ? QuestionBank.answerStats : {};
                const succ = ans.success || 0;
                const fail = ans.failed || 0;
                this._state.bankSuccess = succ;
                this._state.bankFailed = fail;
                this._state.bankAnswerRate = (succ + fail) > 0 ? Math.round((succ / (succ + fail)) * 100) : 0;
                // 云端状态：优先用真实健康检查结果，而不是只看配置开关
                if (CONFIG.cloudBank && CONFIG.cloudBank.enabled) {
                    const cloudOk = !!(CloudBank && CloudBank.isEnabled()) && !!(CloudBank.isHealthy && CloudBank.isHealthy());
                    this._state.bankStatusBadge = cloudOk
                        ? { type: 'success', text: '已连接' }
                        : { type: 'warning', text: '未连接' };
                    // 从未探测过时异步补一次健康检查，完成后刷新徽章
                    try {
                        const st = (CloudBank && CloudBank.getStatus) ? CloudBank.getStatus() : {};
                        if (!st.lastCheck && CloudBank && typeof CloudBank.healthCheck === 'function') {
                            CloudBank.healthCheck().then((h) => {
                                try { this.refreshBankPanel(); } catch (_) {}
                            }).catch(() => {});
                        }
                    } catch (_) {}
                } else {
                    this._state.bankStatusBadge = { type: 'off', text: '未启用' };
                }
                // 云端配置
                this._state.bankCloudEnabled = !!(CONFIG.cloudBank && CONFIG.cloudBank.enabled);
                this._state.bankEndpoint = (CONFIG.cloudBank && CONFIG.cloudBank.endpoint) || '';
                this._state.bankAutoUpload = !!(CONFIG.cloudBank && CONFIG.cloudBank.autoUpload);
                this._state.bankQueryBefore = !!(CONFIG.cloudBank && CONFIG.cloudBank.queryBeforeAI);
                this._state.bankStrategy = (CONFIG.cloudBank && CONFIG.cloudBank.matchStrategy) || 'both';
            } catch (_) {}
        }

        refreshQuestionList() {
            try {
                if (!this._state) return;
                const all = (typeof QuestionBank !== 'undefined' && typeof QuestionBank.all === 'function') ? QuestionBank.all() : [];
                const filter = this._state.bankFilter;
                const q = (filter.q || '').trim().toLowerCase();
                const type = filter.type || 'all';
                const source = filter.source || 'all';
                const filtered = all.filter((r) => {
                    if (!r || !r.qHash) return false;
                    if (type !== 'all' && (r.type || 'single') !== type) return false;
                    if (source !== 'all' && (r.source || 'local') !== source) return false;
                    if (!q) return true;
                    const inQ = (r.question || '').toLowerCase().includes(q);
                    const inOpts = (r.options || []).some((o) => (o.content || '').toLowerCase().includes(q));
                    const inA = (r.answer || '').toLowerCase().includes(q);
                    return inQ || inOpts || inA;
                });
                // 排序：最近更新优先
                filtered.sort((a, b) => ((b.updatedAt || '') + '').localeCompare((a.updatedAt || '') + ''));
                this._state.bankQuestions = filtered.slice(0, 50);
                this._state.bankListCount = filtered.length;
                this._state.bankListTotal = all.length;
            } catch (_) {}
        }

        refreshCoursePanel() {
            try {
                if (!this._state) return;
                if (typeof ProjectInfo !== 'undefined' && typeof ProjectInfo.getDisplayInfo === 'function') {
                    const info = ProjectInfo.getDisplayInfo();
                    this._state.projectInfo = info;
                }
                if (typeof CategoryInfo !== 'undefined' && CategoryInfo.data) {
                    this._state.courseCategories = CategoryInfo.data;
                }
                if (typeof ExamManager !== 'undefined' && ExamManager.data) {
                    this._state.courseExams = ExamManager.data;
                }
                if (Array.isArray(State.pendingCourses)) {
                    this._state.pendingCourses = State.pendingCourses;
                } else if (typeof StudyAssistant !== 'undefined') {
                    this._state.pendingCourses = StudyAssistant.getPendingCourses();
                }
                if (typeof ProjectInfo !== 'undefined' && typeof ProjectInfo.getDisplayInfo === 'function') {
                    this._state.courseSummary = ProjectInfo.getDisplayInfo();
                }
            } catch (_) {}
        }

        refreshProjectData() {
            // "刷新项目数据"按钮：重新拉取项目进度 + 课程分类 + 考试列表（成功写缓存/失败回退缓存）
            try {
                let attempted = 0;
                if (typeof ProjectInfo !== 'undefined' && typeof ProjectInfo.fetchDetails === 'function') {
                    attempted++;
                    ProjectInfo.fetchDetails().then(() => { try { this.refreshCoursePanel(); } catch (_) {} }).catch(() => {});
                }
                if (typeof CategoryInfo !== 'undefined' && typeof CategoryInfo.fetchDetails === 'function') {
                    attempted++;
                    CategoryInfo.fetchDetails().then(() => { try { this.refreshCoursePanel(); } catch (_) {} }).catch(() => {});
                }
                if (typeof ExamManager !== 'undefined' && typeof ExamManager.fetchList === 'function') {
                    attempted++;
                    ExamManager.fetchList().then(() => { try { this.refreshCoursePanel(); } catch (_) {} }).catch(() => {});
                }
                if (typeof StudyAssistant !== 'undefined' && typeof StudyAssistant.fetchCourses === 'function') {
                    attempted++;
                    StudyAssistant.fetchCourses().then((list) => {
                        if (Array.isArray(list)) State.pendingCourses = StudyAssistant.getPendingCourses();
                        try { this.refreshCoursePanel(); } catch (_) {}
                    }).catch(() => {});
                }
                this.refreshCoursePanel();
                safeCall(() => { Logger.info(`刷新项目数据：已触发 ${attempted} 个数据源拉取`); });
            } catch (_) {}
        }

        refreshStats() {
            try {
                const summary = (typeof Statistics !== 'undefined' && typeof Statistics.getSummary === 'function')
                    ? Statistics.getSummary()
                    : { duration: '0:00', coursesCompleted: 0, pagesViewed: 0, errors: 0 };
                this.updateStats(summary);
            } catch (_) {}
        }

        // ============================================================
        // 设置类操作
        // ============================================================

        onDebugModeChange(val) {
            try {
                CONFIG.debugMode = !!val;
                ConfigManager.save();
                if (this._state) this._state.debugBadgeVisible = !!val;
                safeCall(() => Logger.info(`调试模式: ${CONFIG.debugMode ? '开启' : '关闭'}`));
            } catch (_) {}
        }

        onAutoNextChange(val) {
            try {
                CONFIG.autoNextCourse = !!val;
                ConfigManager.save();
            } catch (_) {}
        }

        onTurboModeChange(val) {
            try {
                CONFIG.turboMode = !!val;
                ConfigManager.save();
                if (val) {
                    safeCall(() => { 
                        showFloatToast('⚡ 极速模式已开启！直接接口完成课程（风险较高）', 'warning'); 
                        Logger.warning('[极速模式] 已开启！将跳过真实播放，直接调用接口完成课程');
                        Logger.warning('[极速模式] ⚠️ 风险提示：行为异常易被检测，请谨慎使用');
                    });
                } else {
                    safeCall(() => { 
                        showFloatToast('极速模式已关闭，恢复正常模式', 'success'); 
                        Logger.info('[极速模式] 已关闭，恢复正常模式');
                    });
                }
            } catch (_) {}
        }

        onCanvasAutoBackChange(val) {
            try {
                CONFIG.canvasAutoBack = !!val;
                ConfigManager.save();
                safeCall(() => { showFloatToast(`Canvas微课完成后自动返回列表: ${val ? '开启' : '关闭'}`, val ? 'success' : 'info'); });
            } catch (_) {}
        }

        onRealVideoPlayChange(val) {
            try {
                CONFIG.realVideoPlay = !!val;
                ConfigManager.save();
                safeCall(() => { showFloatToast(`真实视频播放(2x): ${val ? '开启' : '关闭'}`, val ? 'success' : 'info'); });
            } catch (_) {}
        }

        onAutoAdvanceChange(val) {
            try {
                CONFIG.autoAdvanceEnabled = !!val;
                ConfigManager.save();
                safeCall(() => { showFloatToast(`接口自动刷未完成课: ${val ? '开启' : '关闭'}`, val ? 'success' : 'info'); });
            } catch (_) {}
        }

        // ===== 日志设置 =====
        onLogPersistChange(val) {
            try {
                CONFIG.logPersist = !!val;
                ConfigManager.save();
                if (this._state) this._state.logPersist = !!val;
                safeCall(() => Logger.info(`日志持久化: ${val ? '开启' : '关闭'}`));
            } catch (_) {}
        }

        onShowDebugLogsChange(val) {
            try {
                CONFIG.showDebugLogs = !!val;
                ConfigManager.save();
                if (this._state) this._state.showDebugLogs = !!val;
                safeCall(() => Logger.info(`面板显示 debug 日志: ${val ? '开启' : '关闭'}`));
            } catch (_) {}
        }

        onLogMaxChange() {
            try {
                if (!this._state) return;
                const v = Math.max(20, Math.min(500, Number(this._state.logMax) || 100));
                CONFIG.logMax = v;
                ConfigManager.save();
                if (this._state) this._state.logMax = v;
                try { if (typeof Logger !== 'undefined') Logger.maxLogs = v; } catch (_) {}
                // 立即截断面板日志
                if (this._state.logs.length > v) {
                    this._state.logs.splice(v, this._state.logs.length - v);
                }
                safeCall(() => Logger.info(`日志最大条数: ${v}`));
            } catch (_) {}
        }

        onBasicConfigChange() {
            try {
                if (!this._state) return;
                CONFIG.checkInterval = this._state.checkInterval;
                CONFIG.pageTurnDelay = this._state.pageTurnDelay;
                CONFIG.progressThreshold = (this._state.progressThreshold || 90) / 100;
                CONFIG.maxRetryAttempts = this._state.maxRetryAttempts;
                CONFIG.minVideoPlayTime = this._state.minVideoPlayTime;
                CONFIG.videoPlaybackRate = this._state.videoPlaybackRate > 0 ? this._state.videoPlaybackRate : 2;
                CONFIG.courseRepeatLimit = this._state.courseRepeatLimit > 0 ? this._state.courseRepeatLimit : 3;
                ConfigManager.save();
            } catch (_) {}
        }

        saveBasicConfig() {
            this.onBasicConfigChange();
            safeCall(() => { ShuaKeUI.toast('基础设置已保存', 'success', 1500); });
        }

        resetBasicConfig() {
            try {
                const def = (ConfigManager.defaults || {});
                CONFIG.checkInterval = def.checkInterval ?? 1200;
                CONFIG.pageTurnDelay = def.pageTurnDelay ?? 500;
                CONFIG.progressThreshold = def.progressThreshold ?? 0.9;
                CONFIG.maxRetryAttempts = def.maxRetryAttempts ?? 5;
                CONFIG.minVideoPlayTime = def.minVideoPlayTime ?? 5000;
                CONFIG.videoPlaybackRate = def.videoPlaybackRate ?? 2;
                CONFIG.courseRepeatLimit = def.courseRepeatLimit ?? 3;
                CONFIG.debugMode = def.debugMode ?? false;
                CONFIG.autoNextCourse = def.autoNextCourse ?? true;
                CONFIG.turboMode = def.turboMode ?? false;
                CONFIG.realVideoPlay = def.realVideoPlay ?? false;
                CONFIG.autoAdvanceEnabled = def.autoAdvanceEnabled ?? true;
                CONFIG.canvasAutoBack = def.canvasAutoBack ?? false;
                ConfigManager.save();
                this.refreshBasicPanel();
                safeCall(() => Logger.info('基础设置已恢复默认'));
            } catch (_) {}
        }

        onAIAnswerChange(val) {
            try {
                CONFIG.enableAIAnswer = !!val;
                ConfigManager.save();
                this.refreshAIConfigPanel();
                safeCall(() => Logger.info(`AI 答题已${CONFIG.enableAIAnswer ? '启用' : '禁用'}`));
            } catch (_) {}
        }

        saveAIConfig() {
            try {
                if (!this._state) return;
                const known = ['qwen-plus', 'qwen-turbo', 'qwen-max', 'gpt-4o-mini', 'gpt-4o'];
                const model = this._state.aiModel === '__custom__'
                    ? (this._state.aiModelCustom || 'qwen-plus')
                    : this._state.aiModel;
                const useDefault = this._state.aiUseDefaultPrompt;
                CONFIG.aiConfig = {
                    apiUrl: this._state.aiUrl,
                    apiKey: this._state.aiKey,
                    model,
                    timeout: Math.max(5000, Math.min(120000, this._state.aiTimeout)),
                    maxRetries: Math.max(0, Math.min(5, this._state.aiRetries)),
                    temperature: Math.max(0, Math.min(2, this._state.aiTemp)),
                    maxTokens: Math.max(1, Math.min(2000, this._state.aiMaxTokens)),
                    source: this._state.aiSource || 'auto',
                    useDefaultPrompt: useDefault,
                    systemPrompt: useDefault ? '' : this._state.aiPrompt,
                    cloudApiKey: String(this._state.cloudApiKey || '').trim()
                };
                CONFIG.cloudBank = CONFIG.cloudBank || {};
                CONFIG.cloudBank.apiKey = String(this._state.cloudApiKey || '').trim();
                CONFIG.aiApiUrl = this._state.aiUrl;
                CONFIG.aiApiKey = this._state.aiKey;
                CONFIG.aiModel = model;
                CONFIG.aiTimeout = CONFIG.aiConfig.timeout;
                CONFIG.aiMaxRetries = CONFIG.aiConfig.maxRetries;
                CONFIG.enableAIAnswer = this._state.aiAnswerEnabled;
                ConfigManager.save();
                this.refreshAIConfigPanel();
                safeCall(() => { Logger.success('AI 设置已保存'); ShuaKeUI.toast('AI 设置已保存', 'success', 2500); });
            } catch (_) {}
        }

        saveCloudApiKey() {
            try {
                if (!this._state) return;
                let keyVal = String(this._state.cloudApiKey || '').trim();
                if (keyVal === '__custom__') {
                    keyVal = String(this._state.cloudApiKeyCustom || '').trim();
                }
                CONFIG.cloudBank = CONFIG.cloudBank || {};
                CONFIG.cloudBank.apiKey = keyVal;
                ConfigManager.save();
                safeCall(() => Logger.info(`本系统访问 API Key 已${keyVal ? '更新' : '清空（使用登录态鉴权）'}`));
                // 保存后立即刷新「刷课统计上报」状态（API Key 模式实时生效）
                try { if (typeof this._refreshCloudState === 'function') this._refreshCloudState(); } catch (_) {}
            } catch (_) {}
        }

        // 游客上报学习进度开关（持久化到 CONFIG.cloudBank.guestReport）
        saveCloudGuestReport() {
            try {
                if (!this._state) return;
                CONFIG.cloudBank = CONFIG.cloudBank || {};
                CONFIG.cloudBank.guestReport = !!this._state.cloudGuestReport;
                ConfigManager.save();
                safeCall(() => Logger.info(`游客上报学习进度: ${CONFIG.cloudBank.guestReport ? '开启' : '关闭'}`));
                // 保存后立即刷新上报状态（游客模式随开关实时变化）
                try { if (typeof this._refreshCloudState === 'function') this._refreshCloudState(); } catch (_) {}
            } catch (_) {}
        }

        // 自动注册游客账号登录开关（持久化到 CONFIG.cloudBank.autoGuestLogin）
        saveCloudAutoGuestLogin() {
            try {
                if (!this._state) return;
                CONFIG.cloudBank = CONFIG.cloudBank || {};
                CONFIG.cloudBank.autoGuestLogin = !!this._state.cloudAutoGuestLogin;
                ConfigManager.save();
                safeCall(() => Logger.info(`自动注册游客账号登录: ${CONFIG.cloudBank.autoGuestLogin ? '开启' : '已关闭（退出登录后可切换正式账号）'}`));
            } catch (_) {}
        }

        // 切换账号：清除"用户主动退出"标记 → 重新允许自动注册（游客），并打开网页登录页。
        // 面板点击"切换账号"后：若开启自动注册会重新登录游客；随后在网页登录正式账号。
        cloudSwitchAccount() {
            try {
                try { GM_deleteValue('sk_cloud_opt_out'); } catch (_) {}
                try { if (typeof localStorage !== 'undefined') localStorage.removeItem('sk_cloud_opt_out'); } catch (_) {}
                try {
                    if (typeof WeibanAutoAuth !== 'undefined') WeibanAutoAuth._tried = false;
                } catch (_) {}
                safeCall(() => Logger.info('已清除退出标记，可重新自动注册/登录账号'));
                // 自动注册开关开着 → 立即重新注册游客登录态（可选），同时打开网页登录供切换正式账号
                try {
                    const autoOn = !!(CONFIG.cloudBank && CONFIG.cloudBank.autoGuestLogin !== false);
                    if (autoOn && typeof WeibanAutoAuth !== 'undefined' && typeof WeibanAutoAuth.autoRegisterLogin === 'function') {
                        WeibanAutoAuth.autoRegisterLogin().then((r) => {
                            try { if (r && r.ok && this && typeof this.refreshAll === 'function') this.refreshAll(); } catch (_) {}
                        });
                    }
                } catch (_) {}
                this.cloudOpenLogin();
            } catch (_) {}
        }

        // 自动获取账户本系统访问 API Key（后端 /api/apikey/list，脱敏），供管理
        async loadAccountKeys() {
            try {
                if (!this._state) return;
                if (!(typeof CloudAuth !== 'undefined' && CloudAuth.isLoggedIn())) {
                    this._state.cloudAvailableKeys = [];
                    return;
                }
                const CldAI = (typeof CloudAI !== 'undefined') ? CloudAI : null;
                if (!CldAI || typeof CldAI.listAccountKeys !== 'function') return;
                const res = await CldAI.listAccountKeys();
                if (res && res.ok && Array.isArray(res.keys)) {
                    this._state.cloudAvailableKeys = res.keys;
                    // 把带完整 key 的账户 Key 并入下拉框选项（sessionApiKeys 去重，避免与已有项重复）
                    // 后端列表已返回完整 api_key（api_key_masked 仅用于展示脱敏）
                    const session = Array.isArray(this._state.sessionApiKeys) ? this._state.sessionApiKeys : [];
                    const existing = new Set(session.map((k) => k.key));
                    (res.keys || []).forEach((k) => {
                        const fullKey = (k && k.api_key) || '';
                        if (!fullKey || existing.has(fullKey)) return;
                        session.push({ id: k.id, key: fullKey, name: k.name || ('Key#' + k.id) });
                        existing.add(fullKey);
                    });
                    this._state.sessionApiKeys = session;
                    safeCall(() => Logger.info(`已获取账户本系统访问 Key ${res.keys.length} 个，下拉框已同步`));
                }
            } catch (_) {}
        }

        // 兼容旧别名：loadCloudKeys → loadAccountKeys
        async loadCloudKeys() {
            try { if (typeof this.loadAccountKeys === 'function') await this.loadAccountKeys(); } catch (_) {}
        }

        // 新建本系统访问 API Key 并自动设为当前使用
        async createAccountApiKey() {
            try {
                if (!this._state) return;
                const CldAI = (typeof CloudAI !== 'undefined') ? CloudAI : null;
                if (!CldAI || typeof CldAI.createAccountKey !== 'function') return;
                const name = prompt('新建本系统访问 API Key，命名：', '麦课刷课助手');
                if (name == null) return;
                const res = await CldAI.createAccountKey(name);
                if (res && res.ok && res.key) {
                    this._state.sessionApiKeys = this._state.sessionApiKeys || [];
                    this._state.sessionApiKeys.push({ id: res.id, key: res.key, name: res.name || name });
                    this._state.cloudApiKey = res.key;
                    this._state.cloudApiKeyCustom = res.key;
                    this.saveCloudApiKey();
                    safeCall(() => Logger.info(`已新建本系统访问 API Key「${res.name || name}」并设为当前使用（明文仅显示一次，请勿外泄）`));
                    if (typeof this.loadAccountKeys === 'function') this.loadAccountKeys();
                } else {
                    safeCall(() => Logger.warning('新建 API Key 失败：' + ((res && res.error) || '未知原因')));
                }
            } catch (_) {}
        }

        // 删除本系统访问 API Key
        async deleteAccountApiKey(id) {
            try {
                if (!this._state || id == null) return;
                const CldAI = (typeof CloudAI !== 'undefined') ? CloudAI : null;
                if (!CldAI || typeof CldAI.deleteAccountKey !== 'function') return;
                if (!window.confirm('确定删除该本系统访问 API Key？删除后使用该 Key 的请求将失效。')) return;
                const res = await CldAI.deleteAccountKey(id);
                if (res && res.ok) {
                    this._state.sessionApiKeys = (this._state.sessionApiKeys || []).filter((k) => String(k.id) !== String(id));
                    safeCall(() => Logger.info('已删除本系统访问 API Key'));
                    if (typeof this.loadAccountKeys === 'function') this.loadAccountKeys();
                } else {
                    safeCall(() => Logger.warning('删除 API Key 失败：' + ((res && res.error) || '未知原因')));
                }
            } catch (_) {}
        }

        // 测试云端 AI（登录后真实扣费一次，展示余额）
        async testCloudAI() {
            try {
                if (!this._state) return;
                this._state.cloudAITesting = true;
                this._state.cloudAITestResult = null;
                const r = (typeof CloudAI !== 'undefined' && typeof CloudAI.test === 'function')
                    ? await CloudAI.test()
                    : { ok: false, error: '云端 AI 模块不可用' };
                if (r && r.ok) {
                    safeCall(() => { Logger.success(`云端 AI 测试成功，回复: ${r.answer}，余额: ¥${r.balance}`); ShuaKeUI.toast('云端 AI 测试成功', 'success', 2500); });
                    this._state.cloudAITestResult = {
                        ok: true,
                        answer: r.answer,
                        cost: r.cost,
                        balance: r.balance,
                        time: new Date().toLocaleTimeString()
                    };
                    // 同步刷新 profile 余额
                    try { if (typeof this._refreshCloudState === 'function') this._refreshCloudState(); } catch (_) {}
                } else {
                    safeCall(() => Logger.warning(`云端 AI 测试失败: ${r && r.error}`));
                    this._state.cloudAITestResult = {
                        ok: false,
                        error: (r && r.error) || '云端 AI 测试失败',
                        time: new Date().toLocaleTimeString()
                    };
                    safeCall(() => ShuaKeUI.toast('云端 AI 测试失败', 'warning', 4000));
                }
            } catch (e) {
                safeCall(() => Logger.error(`云端 AI 测试异常: ${e.message}`));
                if (this._state) {
                    this._state.cloudAITestResult = {
                        ok: false,
                        error: e.message,
                        time: new Date().toLocaleTimeString()
                    };
                }
            } finally {
                if (this._state) this._state.cloudAITesting = false;
            }
        }

        resetAIConfig() {
            try {
                const def = ((ConfigManager.defaults || {}).aiConfig) || {};
                CONFIG.aiConfig = JSON.parse(JSON.stringify(def));
                CONFIG.aiApiUrl = def.apiUrl || '';
                CONFIG.aiApiKey = def.apiKey || '';
                CONFIG.aiModel = def.model || 'qwen-plus';
                CONFIG.aiTimeout = def.timeout || 30000;
                CONFIG.aiMaxRetries = def.maxRetries || 2;
                ConfigManager.save();
                this.refreshAIConfigPanel();
                safeCall(() => Logger.info('AI 设置已恢复默认'));
            } catch (_) {}
        }

        async testAI() {
            try {
                if (!this._state) return;
                const btn = { disabled: false }; // 模拟禁用状态
                this._state.aiLastResult = null;
                const start = Date.now();
                // 注意：await 优先级高于三元，必须先判定再 await 调用（否则返回未 await 的 Promise 对象）
                const hasFn = typeof AIAnswer !== 'undefined' && typeof AIAnswer.getAnswerFromAI === 'function';
                const ans = hasFn
                    ? await AIAnswer.getAnswerFromAI('测试题目：1+1=?', [
                        { order: 'A', content: '1' },
                        { order: 'B', content: '2' },
                        { order: 'C', content: '3' }
                    ])
                    : null;
                const ms = Date.now() - start;
                if (ans) {
                    safeCall(() => { Logger.success(`AI 测试成功，回复: ${ans}（${ms}ms）`); });
                    this._state.aiLastResult = {
                        ok: true,
                        ans,
                        ms,
                        time: new Date().toLocaleTimeString()
                    };
                    safeCall(() => ShuaKeUI.toast('AI 连接成功', 'success', 2500));
                } else {
                    safeCall(() => Logger.warning('AI 测试失败'));
                    this._state.aiLastResult = {
                        ok: false,
                        error: '未返回答案',
                        ms,
                        time: new Date().toLocaleTimeString()
                    };
                    safeCall(() => ShuaKeUI.toast('AI 测试失败', 'warning', 4000));
                }
            } catch (e) {
                safeCall(() => Logger.error(`AI 测试异常: ${e.message}`));
                if (this._state) {
                    this._state.aiLastResult = {
                        ok: false,
                        error: e.message,
                        time: new Date().toLocaleTimeString()
                    };
                }
            }
        }

        // ============================================================
        // 题库操作
        // ============================================================

        exportBank() {
            try {
                const data = (typeof QuestionBank !== 'undefined' && typeof QuestionBank.exportJSON === 'function')
                    ? QuestionBank.exportJSON()
                    : '{}';
                const blob = new Blob([data], { type: 'application/json' });
                const url = URL.createObjectURL(blob);
                const a = document.createElement('a');
                a.href = url;
                a.download = `刷课题库_${new Date().toISOString().slice(0, 10)}.json`;
                a.click();
                URL.revokeObjectURL(url);
                safeCall(() => { Logger.success('题库已导出'); ShuaKeUI.toast('题库已导出', 'success', 2000); });
            } catch (e) {
                safeCall(() => Logger.error(`导出失败: ${e.message}`));
            }
        }

        importBank() {
            try {
                if (!this._importInput) {
                    this._importInput = document.createElement('input');
                    this._importInput.type = 'file';
                    this._importInput.accept = 'application/json,.json';
                    this._importInput.style.display = 'none';
                    this._importInput.addEventListener('change', async (e) => {
                        const file = e.target.files && e.target.files[0];
                        if (!file) return;
                        try {
                            const text = await file.text();
                            const result = (typeof QuestionBank !== 'undefined' && typeof QuestionBank.importJSON === 'function')
                                ? QuestionBank.importJSON(text, 'merge')
                                : { ok: false };
                            if (result.ok) {
                                safeCall(() => {
                                    Logger.success(`导入完成：新增 ${result.inserted}、合并 ${result.merged}`);
                                    ShuaKeUI.toast(`导入完成：新增 ${result.inserted} 条`, 'success', 3000);
                                });
                            } else {
                                safeCall(() => { Logger.error('导入失败'); ShuaKeUI.toast('导入失败', 'danger', 4000); });
                            }
                        } catch (err) {
                            safeCall(() => Logger.error(`导入失败: ${err.message}`));
                        }
                        this._importInput.value = '';
                        this.refreshBankPanel();
                        this.refreshQuestionList();
                    });
                    (document.body || document.documentElement).appendChild(this._importInput);
                }
                this._importInput.click();
            } catch (_) {}
        }

        async clearBank() {
            try {
                const ok = await ShuaKeUI.confirm('确认清空本地题库？此操作不可恢复。', {
                    title: '清空题库',
                    confirmText: '清空',
                    cancelText: '取消',
                    variant: 'danger'
                });
                if (!ok) return;
                if (typeof QuestionBank !== 'undefined' && typeof QuestionBank.clear === 'function') {
                    QuestionBank.clear();
                }
                safeCall(() => { Logger.warning('本地题库已清空'); ShuaKeUI.toast('题库已清空', 'secondary', 2500); });
                this.refreshBankPanel();
                this.refreshQuestionList();
            } catch (_) {}
        }

        // 删除单条题目
        removeBankRecord(qHash) {
            try {
                if (!qHash) return;
                const removed = (typeof QuestionBank !== 'undefined' && typeof QuestionBank.removeRecord === 'function')
                    ? QuestionBank.removeRecord(qHash) : 0;
                if (removed > 0) {
                    safeCall(() => { Logger.info(`已删除 1 条题目`); ShuaKeUI.toast('已删除', 'success', 2000); });
                    this.refreshBankPanel();
                    this.refreshQuestionList();
                }
            } catch (_) {}
        }

        // 切换某题的"已验证"标记
        toggleBankVerified(qHash) {
            try {
                if (!qHash) return;
                const changed = (typeof QuestionBank !== 'undefined' && typeof QuestionBank.toggleVerified === 'function')
                    ? QuestionBank.toggleVerified(qHash) : false;
                if (changed) {
                    safeCall(() => { Logger.info(`已切换题目验证状态`); });
                    this.refreshBankPanel();
                    this.refreshQuestionList();
                }
            } catch (_) {}
        }

        // 修改某题的答案
        async editBankAnswer(qHash) {
            try {
                if (!qHash) return;
                const rec = (typeof QuestionBank !== 'undefined' && typeof QuestionBank.findByHash === 'function')
                    ? QuestionBank.findByHash(qHash) : null;
                if (!rec) {
                    safeCall(() => { Logger.warning('题目不存在'); ShuaKeUI.toast('题目不存在', 'warning', 2500); });
                    return;
                }
                const qShort = (rec.question || '').slice(0, 40);
                const res = await ShuaKeUI.prompt(
                    `修改答案：${qShort}\n当前答案：${rec.answer || '（空）'}`,
                    {
                        title: '修改答案',
                        defaultValue: rec.answer || '',
                        placeholder: '如 A / ABC / 对',
                        confirmText: '保存',
                        cancelText: '取消'
                    }
                );
                if (!res.ok || !res.value) return;
                const ok = (typeof QuestionBank !== 'undefined' && typeof QuestionBank.updateAnswer === 'function')
                    ? QuestionBank.updateAnswer(qHash, res.value) : false;
                if (ok) {
                    safeCall(() => {
                        Logger.success(`答案已更新为 ${res.value}`);
                        ShuaKeUI.toast(`答案已更新为 ${res.value}`, 'success', 2500);
                    });
                    this.refreshBankPanel();
                    this.refreshQuestionList();
                } else {
                    safeCall(() => { Logger.warning('答案未更新（值为空或未找到题目）'); });
                }
            } catch (_) {}
        }

        // 清空命中统计
        resetBankStats() {
            try {
                if (typeof QuestionBank !== 'undefined' && typeof QuestionBank.resetStats === 'function') {
                    QuestionBank.resetStats();
                }
                if (typeof QuestionBank !== 'undefined' && typeof QuestionBank.resetAnswerStats === 'function') {
                    QuestionBank.resetAnswerStats();
                }
                safeCall(() => { Logger.info('命中统计与答题统计已重置'); ShuaKeUI.toast('统计已重置', 'success', 2000); });
                this.refreshBankPanel();
            } catch (_) {}
        }

        async testBankConnection() {
            try {
                if (typeof CloudBank !== 'undefined' && typeof CloudBank.healthCheck === 'function') {
                    safeCall(() => Logger.info('正在测试云端连接...'));
                    const ok = await CloudBank.healthCheck();
                    if (ok) {
                        safeCall(() => { Logger.success('云端连接正常'); ShuaKeUI.toast('连接正常', 'success', 2500); });
                    } else {
                        const err = (CloudBank && CloudBank.getStatus && CloudBank.getStatus().lastError) || '未知';
                        safeCall(() => { Logger.warning(`云端连接失败: ${err}`); ShuaKeUI.toast('连接失败', 'warning', 3500); });
                    }
                    this.refreshBankPanel();
                }
            } catch (_) {}
        }

        async uploadBankAll() {
            try {
                if (!CONFIG.cloudBank || !CONFIG.cloudBank.enabled) {
                    safeCall(() => Logger.warning('请先启用云端题库'));
                    return;
                }
                const records = (typeof QuestionBank !== 'undefined' && typeof QuestionBank.all === 'function') ? QuestionBank.all() : [];
                if (records.length === 0) {
                    safeCall(() => Logger.info('本地题库为空'));
                    return;
                }
                safeCall(() => Logger.info(`开始批量上传 ${records.length} 条...`));
                if (typeof CloudBank !== 'undefined' && typeof CloudBank.batchUpload === 'function') {
                    const res = await CloudBank.batchUpload(records);
                    if (res && res.ok) {
                        safeCall(() => Logger.success(`批量上传完成：新增 ${res.inserted}、合并 ${res.merged}`));
                    } else {
                        safeCall(() => Logger.error(`批量上传失败: ${res?.error || 'unknown'}`));
                    }
                    this.refreshBankPanel();
                }
            } catch (_) {}
        }

        onBankCloudEnabledChange(val) {
            try {
                CONFIG.cloudBank = CONFIG.cloudBank || {};
                CONFIG.cloudBank.enabled = !!val;
                ConfigManager.save();
                safeCall(() => Logger.info(`云端题库已${CONFIG.cloudBank.enabled ? '启用' : '禁用'}`));
                if (CONFIG.cloudBank.enabled) {
                    (async () => {
                        if (typeof CloudBank !== 'undefined' && typeof CloudBank.healthCheck === 'function') {
                            await CloudBank.healthCheck();
                            this.refreshBankPanel();
                        }
                    })();
                }
                this.refreshBankPanel();
            } catch (_) {}
        }

        onBankEndpointChange() {
            try {
                CONFIG.cloudBank = CONFIG.cloudBank || {};
                CONFIG.cloudBank.endpoint = (this._state && this._state.bankEndpoint) || '';
                ConfigManager.save();
            } catch (_) {}
        }

        onBankAutoUploadChange(val) {
            try {
                CONFIG.cloudBank = CONFIG.cloudBank || {};
                CONFIG.cloudBank.autoUpload = !!val;
                ConfigManager.save();
            } catch (_) {}
        }

        onBankQueryBeforeChange(val) {
            try {
                CONFIG.cloudBank = CONFIG.cloudBank || {};
                CONFIG.cloudBank.queryBeforeAI = !!val;
                ConfigManager.save();
            } catch (_) {}
        }

        onBankStrategyChange(val) {
            try {
                CONFIG.cloudBank = CONFIG.cloudBank || {};
                CONFIG.cloudBank.matchStrategy = val;
                ConfigManager.save();
            } catch (_) {}
        }

        // 云端题库设置恢复默认
        resetCloudBankConfig() {
            try {
                const def = ((ConfigManager.defaults || {}).cloudBank) || {};
                CONFIG.cloudBank = JSON.parse(JSON.stringify(def));
                ConfigManager.save();
                this.refreshCloudBankPanel();
                safeCall(() => { Logger.info('云端题库设置已恢复默认'); ShuaKeUI.toast('云端设置已恢复默认', 'success', 1500); });
            } catch (_) {}
        }

        // ============================================================
        // 云端账户
        // ============================================================

        _refreshCloudState() {
            try {
                if (!this._state) return;
                const loggedIn = (typeof CloudAuth !== 'undefined') ? CloudAuth.isLoggedIn() : false;
                const user = (typeof CloudAuth !== 'undefined') ? CloudAuth.getUser() : null;
                this._state.cloudLoggedIn = loggedIn;
                this._state.cloudUser = user;
                // 刷课统计上报认证模式（对齐刷课统计 API 文档：X-API-Key 优先 → JWT → 游客）
                {
                    let sk = '';
                    try { sk = String((CONFIG && CONFIG.cloudBank && CONFIG.cloudBank.apiKey) || '').trim(); } catch (_) {}
                    let mode = 'off';
                    if (sk !== '') mode = 'api-key';
                    else if (loggedIn) mode = 'jwt';
                    else {
                        try { if (typeof GuestReporter !== 'undefined' && GuestReporter.isEnabled()) mode = 'guest'; } catch (_) {}
                    }
                    this._state.studyReportMode = mode;
                }
                this._state.cloudGuest = (typeof CloudAuth !== 'undefined' && typeof CloudAuth.isGuestAccount === 'function') ? CloudAuth.isGuestAccount() : false;
                if (loggedIn && user) {
                    // 异步获取最新 profile（含余额）
                    if (typeof CloudAuth !== 'undefined' && typeof CloudAuth.getProfile === 'function') {
                        CloudAuth.getProfile().then(res => {
                            if (res && res.ok && res.user && this._state) {
                                this._state.cloudProfile = res.user;
                            }
                        }).catch(() => {});
                    }
                } else {
                    this._state.cloudProfile = null;
                }
            } catch (_) {}
        }

        cloudLogin() {
            try {
                const email = (this._state && this._state.cloudEmail) || '';
                const password = (this._state && this._state.cloudPassword) || '';
                if (!email || !password) {
                    if (this._state) this._state.cloudStatusMsg = '请输入邮箱和密码';
                    return;
                }
                if (this._state) this._state.cloudStatusMsg = '登录中...';
                (async () => {
                    const res = await CloudAuth.login({ email, password });
                    if (res.ok) {
                        // 正式账号登录成功 = 用户主动切换账号 → 清除"不再自动注册游客"标记
                        try { GM_deleteValue('sk_cloud_opt_out'); } catch (_) {}
                        try { if (typeof localStorage !== 'undefined') localStorage.removeItem('sk_cloud_opt_out'); } catch (_) {}
                        if (this._state) {
                            this._state.cloudStatusMsg = '';
                            this._state.cloudPassword = '';
                            this._state.cloudLoggedIn = true;
                            this._state.cloudUser = res.user;
                            this._state.cloudProfile = res.user;
                            this._state.cloudGuest = (typeof CloudAuth.isGuestAccount === 'function') ? CloudAuth.isGuestAccount() : false;
                        }
                        safeCall(() => { Logger.success('云端账户登录成功'); ShuaKeUI.toast('登录成功', 'success', 2000); });
                        // 登录后同步刷新云端题库连通状态与设置回显
                        try { if (typeof this.refreshBankPanel === 'function') this.refreshBankPanel(); } catch (_) {}
                        try { if (typeof this.refreshCloudBankPanel === 'function') this.refreshCloudBankPanel(); } catch (_) {}
                    } else {
                        if (this._state) this._state.cloudStatusMsg = res.error || '登录失败';
                    }
                })();
            } catch (_) {
                if (this._state) this._state.cloudStatusMsg = '登录异常';
            }
        }

        cloudSendCode() {
            try {
                const email = (this._state && this._state.cloudEmail) || '';
                if (!email) {
                    if (this._state) this._state.cloudSendCodeMsg = '请先填写邮箱';
                    return;
                }
                if (this._state) {
                    this._state.cloudSendingCode = true;
                    this._state.cloudSendCodeMsg = '发送中...';
                }
                (async () => {
                    const res = await CloudAuth.sendRegisterCode({ email });
                    if (this._state) {
                        this._state.cloudSendingCode = false;
                        this._state.cloudSendCodeMsg = res.ok
                            ? (res.message || '验证码已发送，请查收邮箱')
                            : (res.error || '发送失败');
                    }
                })();
            } catch (_) {}
        }

        cloudOpenLogin() {
            // 登录跳转到云端 Web 前端登录页（登录/注册/忘记密码均跳转网页端）
            try { window.open('http://mk.heymeta.cn/#/login', '_blank'); } catch (_) {}
        }

        cloudRegister() {
            // 注册跳转到云端 Web 前端注册页
            try { window.open('http://mk.heymeta.cn/#/register', '_blank'); } catch (_) {}
        }

        // 手动合并游客数据到当前登录账号（服务端未实现时提示）
        async mergeGuestData() {
            try {
                if (this._state) this._state.cloudStatusMsg = '正在合并游客数据...';
                let res = null;
                if (typeof WeibanAutoAuth !== 'undefined' && typeof WeibanAutoAuth.mergeGuestData === 'function') {
                    res = await WeibanAutoAuth.mergeGuestData();
                }
                if (res && typeof res === 'object') {
                    if (this._state) this._state.cloudStatusMsg = '游客数据已合并到本账号';
                    safeCall(() => { Logger.success('游客数据已合并到本账号'); ShuaKeUI.toast('合并成功', 'success', 2200); });
                } else {
                    if (this._state) this._state.cloudStatusMsg = '合并未完成（服务端需实现 POST /api/study/merge-guest）';
                    safeCall(() => Logger.warning('合并游客数据失败：服务端需实现 POST /api/study/merge-guest'));
                }
            } catch (_) {
                if (this._state) this._state.cloudStatusMsg = '合并游客数据异常';
            }
        }

        cloudLogout() {
            try {
                const logoutFn = async () => {
                    if (typeof CloudAuth !== 'undefined' && typeof CloudAuth.logout === 'function') {
                        await CloudAuth.logout();
                    }
                    if (this._state) {
                        this._state.cloudLoggedIn = false;
                        this._state.cloudUser = null;
                        this._state.cloudProfile = null;
                        this._state.cloudEmail = '';
                        this._state.cloudPassword = '';
                        this._state.cloudStatusMsg = '';
                    }
                };
                logoutFn();
            } catch (_) {}
        }

        cloudPushConfig() {
            try {
                if (!this._state || !this._state.cloudLoggedIn) {
                    ShuaKeUI.toast('请先登录云端账户', 'warning', 2500);
                    return;
                }
                if (this._state) this._state.cloudStatusMsg = '同步中...';
                (async () => {
                    const includeKey = !!(this._state && this._state.cloudIncludeKey);
                    const res = await CloudConfig.push({ includeKey });
                    if (this._state) {
                        this._state.cloudStatusMsg = res.ok ? '' : (res.error || '同步失败');
                    }
                    if (res.ok) {
                        safeCall(() => { Logger.success('配置已同步到云端'); ShuaKeUI.toast('同步成功', 'success', 2000); });
                    } else {
                        safeCall(() => { Logger.error('同步失败: ' + (res.error || '')); ShuaKeUI.toast(res.error || '同步失败', 'error', 3000); });
                    }
                })();
            } catch (_) {}
        }

        cloudPullConfig() {
            try {
                if (!this._state || !this._state.cloudLoggedIn) {
                    ShuaKeUI.toast('请先登录云端账户', 'warning', 2500);
                    return;
                }
                (async () => {
                    const includeKey = !!(this._state && this._state.cloudIncludeKey);
                    const res = await CloudConfig.pull({ includeKey });
                    if (res.ok) {
                        safeCall(() => { Logger.success('配置已从云端拉取'); ShuaKeUI.toast('拉取成功', 'success', 2000); });
                        // 拉取后统一刷新「设置」tab 全部项（基础 / AI / 云端题库 / 日志），保证界面回显与 CONFIG 一致
                        if (typeof this.refreshSettingsAll === 'function') this.refreshSettingsAll();
                    } else {
                        safeCall(() => { Logger.error('拉取失败: ' + (res.error || '')); ShuaKeUI.toast(res.error || '拉取失败', 'warning', 3000); });
                    }
                })();
            } catch (_) {}
        }

        cloudOpenForgot() {
            // 跳转到云端 Web 前端忘记密码页
            try { window.open('http://mk.heymeta.cn/#/forgot-password', '_blank'); } catch (_) {}
        }

        // ============================================================
        // 日志
        // ============================================================

        clearLogs() {
            try {
                if (this._state) {
                    this._state.logs = [];
                }
                // 同时清空内存 + 持久化日志
                try {
                    if (typeof Logger !== 'undefined') {
                        Logger.logs = [];
                        if (typeof Logger._clearPersist === 'function') Logger._clearPersist();
                    }
                } catch (_) {}
                safeCall(() => ShuaKeUI.toast('日志已清空', 'secondary', 1500));
            } catch (_) {}
        }

        // ============================================================
        // 清空本地缓存（题库/日志/统计/记录/历史/身份快照；保留登录态与配置）
        // ============================================================
        async clearLocalCache() {
            try {
                const ok = await ShuaKeUI.confirm('确认清空本地缓存？将删除题库、日志、统计、刷课记录、课程历史、身份快照等本地数据。\n保留：站点登录态、云端账户、面板设置。此操作不可恢复。', {
                    title: '清空本地缓存',
                    confirmText: '清空',
                    cancelText: '取消',
                    variant: 'danger'
                });
                if (!ok) return;
                let removed = 0;
                // 1) localStorage 中所有 shuake_* 键（白名单保留：配置/面板状态/云端登录态）
                const KEEP = new Set(['shuake_config', 'shuake_panel_state', 'shuake_cloud_auth_v1']);
                try {
                    const toRemove = [];
                    for (let i = 0; i < localStorage.length; i++) {
                        const k = localStorage.key(i);
                        if (k && k.indexOf('shuake_') === 0 && !KEEP.has(k)) toRemove.push(k);
                    }
                    for (const k of toRemove) { try { localStorage.removeItem(k); removed++; } catch (_) {} }
                } catch (_) {}
                // 2) GM 键（待处理极速任务标记）
                try { if (typeof GM_deleteValue === 'function') { GM_deleteValue('shuake_pending_turbo'); removed++; } } catch (_) {}
                // 3) 内存状态
                try {
                    if (typeof Logger !== 'undefined') { Logger.logs = []; if (typeof Logger._clearPersist === 'function') Logger._clearPersist(); }
                } catch (_) {}
                try { if (typeof Statistics !== 'undefined' && typeof Statistics.reset === 'function') Statistics.reset(); } catch (_) {}
                try { if (typeof QuestionBank !== 'undefined' && typeof QuestionBank.clear === 'function') QuestionBank.clear(); } catch (_) {}
                try { if (typeof DataCache !== 'undefined') DataCache._identity = null; } catch (_) {}
                if (this._state) {
                    try { this._state.logs = []; } catch (_) {}
                    try { this._state.questionRecords = []; } catch (_) {}
                    try { this.refreshStats(); } catch (_) {}
                }
                safeCall(() => ShuaKeUI.toast(`已清空 ${removed} 项本地缓存，建议刷新页面生效`, 'success', 2500));
            } catch (_) {}
        }

        _exportLogs() {
            try {
                const logs = (this._state && this._state.logs) || [];
                if (logs.length === 0) {
                    safeCall(() => ShuaKeUI.toast('暂无日志可导出', 'secondary', 1500));
                    return;
                }
                const entries = logs
                    .filter((l) => l.message)
                    .map((l) => {
                        const t = l.ts ? new Date(l.ts).toLocaleString('zh-CN', { hour12: false }) : l.time;
                        const count = (l.count && l.count > 1) ? ` ×${l.count}` : '';
                        return `[${t}] [${(l.level || 'info').toUpperCase()}] ${l.message}${count}`;
                    });
                const text = entries.join('\n');
                const blob = new Blob([text], { type: 'text/plain;charset=utf-8' });
                const url = URL.createObjectURL(blob);
                const a = document.createElement('a');
                a.href = url;
                a.download = `刷课日志_${new Date().toISOString().slice(0, 10)}.txt`;
                a.click();
                URL.revokeObjectURL(url);
                safeCall(() => { Logger.info(`已导出 ${entries.length} 条日志`); ShuaKeUI.toast(`导出 ${entries.length} 条日志`, 'success', 2000); });
            } catch (_) {}
        }

        exportLogs() {
            this._exportLogs();
        }

        // ============================================================
        // 版本检测与更新
        // ============================================================
        async checkVersion() {
            try {
                if (!this._state || !this._state.versionInfo) return;
                if (this._state.versionInfo.checking) return;
                this._state.versionInfo.checking = true;
                this._state.versionInfo.error = '';
                const result = await VersionChecker.check(this._state.versionInfo.channel || 'stable');
                this._state.versionInfo.latest = result.latest;
                this._state.versionInfo.needUpdate = result.needUpdate;
                this._state.versionInfo.force = result.force;
                this._state.versionInfo.changelog = result.changelog;
                this._state.versionInfo.downloadUrl = result.downloadUrl;
                this._state.versionInfo.fallbackUrl = result.fallbackUrl;
                this._state.versionInfo.minClientVersion = result.minClientVersion;
                this._state.versionInfo.channel = result.channel;
                this._state.versionInfo.fileSha256 = result.fileSha256;
                this._state.versionInfo.reason = result.reason;
                this._state.versionInfo.lastCheck = new Date().toLocaleTimeString();
                if (result.force && result.needUpdate && result.downloadUrl) {
                    try {
                        const ok = await ShuaKeUI.confirm(
                            '检测到强制更新版本 ' + result.latest + '，当前版本过低必须升级。是否立即下载？',
                            { title: '强制更新', confirmText: '下载', cancelText: '稍后', variant: 'danger' }
                        );
                        if (ok) { try { window.open(result.downloadUrl, '_blank'); } catch (_) {} }
                        try { GM_setValue('forceUpdateRequired', result.latest); } catch (_) {}
                    } catch (_) {}
                }
                safeCall(() => ShuaKeUI.toast(
                    result.needUpdate ? ('发现新版本 ' + result.latest) : '已是最新版本',
                    result.needUpdate ? 'warning' : 'success', 2000
                ));
            } catch (e) {
                if (this._state && this._state.versionInfo) {
                    this._state.versionInfo.error = (e && e.message) || '网络错误';
                }
                safeCall(() => ShuaKeUI.toast('版本检查失败', 'error', 2000));
            } finally {
                if (this._state && this._state.versionInfo) this._state.versionInfo.checking = false;
            }
        }

        openDownload() {
            try {
                const url = (this._state && this._state.versionInfo && this._state.versionInfo.downloadUrl) || '';
                if (!url) return;
                window.open(url, '_blank');
            } catch (_) {}
        }

        // ============================================================
        // 统计
        // ============================================================

        async resetStats() {
            try {
                const ok = await ShuaKeUI.confirm('确认重置所有统计数据？此操作不可恢复。', {
                    title: '重置统计',
                    confirmText: '重置',
                    cancelText: '取消',
                    variant: 'danger'
                });
                if (!ok) return;
                if (typeof Statistics !== 'undefined') {
                    if (typeof Statistics.reset === 'function') {
                        Statistics.reset();
                    } else {
                        Statistics.coursesCompleted = 0;
                        Statistics.totalPagesViewed = 0;
                        Statistics.totalErrors = 0;
                        try { Statistics.save?.(); } catch (_) {}
                    }
                }
                this.refreshStats();
                safeCall(() => ShuaKeUI.toast('统计数据已重置', 'success', 1500));
            } catch (_) {}
        }

        _exportStats() {
            try {
                const summary = (typeof Statistics !== 'undefined' && typeof Statistics.getSummary === 'function')
                    ? Statistics.getSummary()
                    : { duration: '0:00', coursesCompleted: 0, pagesViewed: 0, errors: 0 };
                const stats = (typeof QuestionBank !== 'undefined' && QuestionBank.stats) ? QuestionBank.stats : {};
                const data = {
                    __type: 'shuake-stats',
                    exportedAt: new Date().toISOString(),
                    ...summary,
                    questionBank: {
                        total: (typeof QuestionBank !== 'undefined' && typeof QuestionBank.count === 'function') ? QuestionBank.count() : 0,
                        localHits: stats.localHits || 0,
                        cloudHits: stats.cloudHits || 0,
                        aiHits: stats.aiHits || 0
                    }
                };
                const blob = new Blob([SafeJSON.stringify(data, '{}')], { type: 'application/json' });
                const url = URL.createObjectURL(blob);
                const a = document.createElement('a');
                a.href = url;
                a.download = `刷课统计_${new Date().toISOString().slice(0, 10)}.json`;
                a.click();
                URL.revokeObjectURL(url);
                safeCall(() => ShuaKeUI.toast('统计已导出', 'success', 1500));
            } catch (_) {}
        }

        exportStats() {
            this._exportStats();
        }
    }

    // ========== 页面类型检测 ==========
    const PageType = {
        isCaptcha(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            // 只检测真正显示的验证码 DOM 元素
            const captchaSelectors = [
                '.tencent-captcha',          // 腾讯验证码容器
                '[class*="tencent-captcha"]', // 腾讯验证码相关
                '#tencent_captcha',          // 腾讯验证码 ID
                '.captcha-container',        // 通用验证码容器
                '[class*="captcha-modal"]',  // 验证码弹窗
                '.tcaptcha',                // 腾讯防水墙
                '#tcaptcha',                // 腾讯防水墙 ID
                '#tcaptcha_transform_dy'    // 腾讯防水墙 transform
            ];

            for (const sel of captchaSelectors) {
                try {
                    const el = doc.querySelector(sel);
                    if (!el) continue;
                    // 获取计算样式
                    const style = window.getComputedStyle(el);
                    if (!style) continue;

                    // 检查 opacity 是否大于 0
                    const opacity = parseFloat(style.opacity);
                    if (isNaN(opacity) || opacity <= 0) continue;

                    // 检查 display 是否不是 none
                    if (style.display === 'none') continue;

                    // 检查 visibility 是否不是 hidden
                    if (style.visibility === 'hidden') continue;

                    // 检查是否在可视区域内
                    let rect;
                    try { rect = el.getBoundingClientRect(); } catch (_) { continue; }
                    if (!rect) continue;
                    if (rect.top < -1000 || rect.left < -1000) continue;

                    // 检查元素尺寸
                    if (el.offsetWidth <= 0 || el.offsetHeight <= 0) continue;

                    // 所有检查通过
                    return true;
                } catch (e) {
                    continue;
                }
            }
            return false;
        },

        isVideo(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                // ========== 根据《刷课流程解析.md》视频判定标准 ==========
                // 视频核心特征：
                //   1) <video> 标签（如 id="my-video_html5_api" class="vjs-tech"）
                //   2) <source> 子标签 src 指向 .m3u8 或 .mp4（必填特征，避免与空 video 占位混淆）
                //   3) 页面加载 video-js-cdn.min.js / videojs-contrib-hls.min.js / video-play-loader.js
                //   4) 播放器容器：.video-js / #my-video / .my-video-dimensions / 各种第三方播放器
                // 视频页面常常同时含 .content-txt/.content-pic，因此优先用更稳定的特征。

                // 新版图文课件模板（item.js 新版）：page-0 用 xgplayer 建"空 URL 播放器桩"，
                // 空 src 的 <video>/.xgplayer 不算视频特征，避免图文页被误判为视频页。
                let _hasRealVideoSrc = false;
                try {
                    const _v = doc.querySelector('video');
                    if (_v) {
                        let _s = (_v.getAttribute && _v.getAttribute('src')) || (_v.currentSrc) || '';
                        if (_s && String(_s).trim() && String(_s) !== 'about:blank') _hasRealVideoSrc = true;
                        if (!_hasRealVideoSrc) {
                            const _srcs = _v.querySelectorAll('source[src]');
                            for (let i = 0; i < _srcs.length; i++) {
                                const _x = _srcs[i].getAttribute('src') || '';
                                if (_x && String(_x).trim()) { _hasRealVideoSrc = true; break; }
                            }
                        }
                        try { if (_v.duration && _v.duration > 0) _hasRealVideoSrc = true; } catch (_) {}
                    }
                } catch (_) {}

// 图文课程守卫：页面有图文课程结构标记（.page-item/.page-start/.page-reciprocal/.page-end/答题/翻页）时，
// 即使内含真实内嵌视频（如新版图文模板 page-0 的 xgplayer 真实 mp4），也按图文课程处理，
// 不判定为纯视频课（避免 skipGraphicFlow=true 跳过整个图文开始/答题/翻页/结束流程）。
try {
    if (doc.querySelector('.page-item, .page-start, .page-reciprocal, .page-end, .btn-next, .btn-aq, .btn-at, .btn-af, .btn-aq-n, .btn-aq-y')) return false;
} catch (_) {}

                // --- 第 1 梯队：<video> + <source> 精确匹配（文档要求的最权威特征） ---
                try {
                    const videoEl = doc.querySelector('video');
                    if (videoEl) {
                        // 有 source 子元素指向视频资源
                        const sources = videoEl.querySelectorAll('source[src]');
                        let hasVideoSrc = false;
                        for (let i = 0; i < sources.length; i++) {
                            const s = sources[i].getAttribute('src') || '';
                            if (/\.m3u8($|\?)/i.test(s) || /\.mp4($|\?)/i.test(s) ||
                                /type\s*=\s*["']?video\//i.test(sources[i].outerHTML) ||
                                /application\/x-mpegURL/i.test(sources[i].type || '')) {
                                hasVideoSrc = true;
                                break;
                            }
                        }
                        // 或者 video 自身有 src
                        const videoSrc = videoEl.getAttribute('src') || '';
                        if (hasVideoSrc || /\.m3u8|\.mp4/i.test(videoSrc)) return true;

                        // 或者是被 videojs/xgplayer 等包装的已初始化 video（class 带 vjs-tech/xgplayer 等）
                        // 需带真实源，排除空 URL 播放器桩
                        if (/vjs-tech|xgplayer|dplayer|artplayer|ckplayer/i.test(videoEl.className || '') && _hasRealVideoSrc) return true;

                        // 有明显尺寸的原生 video（需带真实源，排除空 URL 播放器桩）
                        if (_hasRealVideoSrc && ((videoEl.offsetWidth > 100 && videoEl.offsetHeight > 60) ||
                            (videoEl.getAttribute('poster') && videoEl.getAttribute('poster').length > 0))) {
                            return true;
                        }
                    }
                } catch (_) {}

                // --- 第 2 梯队：视频相关脚本加载（文档要求的辅助特征） ---
                try {
                    const scripts = doc.querySelectorAll('script[src]');
                    for (let i = 0; i < scripts.length; i++) {
                        const src = scripts[i].getAttribute('src') || '';
                        // 旧版 videojs 系列 loader：无条件视为视频
                        if (/video-js-cdn\.min\.js/i.test(src) || /videojs-contrib-hls\.min\.js/i.test(src)) {
                            return true;
                        }
                        // video-play-loader（新版模板图文/视频共用）：仅当页面确有真实视频源才算视频
                        if ((/video-play-loader\.js/i.test(src) || /video-play-unlodaer\.js/i.test(src)) && _hasRealVideoSrc) {
                            return true;
                        }
                    }
                } catch (_) {}

                // --- 第 3 梯队：各种播放器容器（兜底） ---
                const playerContainers = [
                    '.video-js, .vjs-tech',
                    '.dplayer, #dplayer, [class*="dplayer"]',
                    '[class*="artplayer"], #artplayer, .artplayer',
                    '[class*="ckplayer"], #ckplayer',
                    'iframe[src*="video"], iframe[src*="player"]',
                    // mcwk 视频页根标记（文档示例：.my-video-dimensions / .page-video 等）
                    '.page-video, [class*="page-video"], section.video-page, .my-video-dimensions',
                    '#my-video'
                ];
                for (const sel of playerContainers) {
                    try {
                        if (doc.querySelector(sel)) return true;
                    } catch (_) {}
                }
                // xgplayer（新版模板图文/视频共用）：仅当带真实视频源才算视频
                try {
                    if (_hasRealVideoSrc && doc.querySelector('.xgplayer, #xgplayer, [class*="xgplayer"]')) return true;
                } catch (_) {}
                return false;
            } catch (e) {
                return false;
            }
        },

        isGraphic(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            // ========== 根据《刷课流程解析.md》图文判定标准 ==========
            // 图文核心特征（文档第 48-49 行明确给出）：
            //   1) 使用 <section> 标签结构
            //   2) 使用 <canvas> 标签（canvas 类互动微课，这是现有代码的缺失项）
            // 视频页面常常同时含 .content-txt / .content-pic，因此：
            //   - 【先排除已知视频特征】再看图文标识
            //   - 避免过宽的 [class*="content"] 选择器
            try {
                // 前置防御：若 document 本身已经是视频页（有 video/source），直接返回 false，防止误判。
                // 但若页面有明确的图文课程结构标记（.page-item/.page-start/答题/翻页），
                // 即使内含真实内嵌视频（如新版图文模板 page-0 的 xgplayer），也视为图文而非纯视频课。
                if (!doc.querySelector('.page-item, .page-start, .page-reciprocal, .page-end, .btn-next, .btn-aq, .btn-at, .btn-af, .btn-aq-n, .btn-aq-y')) {
                    if (DOMUtils.isVideo(doc)) return false;
                }
            } catch (_) {}

            // --- 第 1 梯队：<canvas> 标签（文档要求的图文独有特征，最优先，之前缺失） ---
            try {
                const canvasEl = doc.querySelector('canvas');
                if (canvasEl) {
                    // 排除非可见/占位 canvas
                    const w = parseInt(canvasEl.getAttribute('width') || String(canvasEl.offsetWidth || 0), 10);
                    const h = parseInt(canvasEl.getAttribute('height') || String(canvasEl.offsetHeight || 0), 10);
                    if ((w >= 100 && h >= 100) ||
                        /canvas|game|interactive|stage|scene/i.test(canvasEl.className + ' ' + (canvasEl.id || ''))) {
                        return true;
                    }
                    // iframe 中 canvas 可能未设置 width 属性，按数量兜底
                    if (doc.querySelectorAll('canvas').length >= 1) {
                        // 只要非视频页并且出现 canvas → 基本就是图文（或互动图文）
                        return true;
                    }
                }
            } catch (_) {}

            // --- 第 2 梯队：<section> 结构组合（文档要求的图文特征） ---
            // 文档：图文页使用 <section> 作为主要容器；视频页虽然也有 section，但视频优先被 isVideo 拦截。
            try {
                const sections = doc.querySelectorAll('section');
                const sectionCount = sections ? sections.length : 0;
                if (sectionCount >= 1) {
                    // 查找图文 section 内的典型子结构（page-item/page-slide 或 滚动/翻页容器）
                    const hasGraphicSectionChildren = doc.querySelector(
                        'section .page-item, section .page-slide, section .swiper-slide, section .slider-item'
                    );
                    if (hasGraphicSectionChildren) return true;
                    // 纯 section 文字（图文静态页）：单 section 要求更长文本（避免单 section 的视频页误伤）
                    // 注意：此处已通过 DOMUtils.isVideo(doc) 排除了典型视频特征，但仍可能残留视频占位。
                    const minTextLen = sectionCount >= 2 ? 100 : 200;
                    const longTextInSection = (() => {
                        let totalLen = 0;
                        for (let i = 0; i < sections.length; i++) {
                            totalLen += (sections[i].textContent || '').trim().length;
                        }
                        return totalLen > minTextLen;
                    })();
                    if (longTextInSection &&
                        // isGraphic 开头已通过 DOMUtils.isVideo(doc) 排除典型视频；
                        // 这里只排除明确的视频容器特征，避免"占位 video 元素 + 大段图文"被误伤为未识别。
                        !doc.querySelector('.video-js, .xgplayer, [class*="page-video"], .my-video-dimensions, .vjs-tech, [class*="xgplayer"]')) {
                        return true;
                    }
                }
            } catch (_) {}

            // --- 第 3 梯队：图文专用 class / 属性指示器（按文档补充） ---
            const indicators = [
                '.page-item',              // 麦课图文页码指示器
                '.page-slide',             // 翻页容器
                '.graphic-content',        // 图文内容主容器
                '.graphic-page',
                '.swiper-slide',           // 轮播幻灯片（图文常用）
                '.slider-item',            // 滑块项目
                // 麦课图文典型的 section.class 片段
                '.content-page',
                '.article-content',
                '.text-content',
                // 图文互动常见容器
                '[class*="swiper-container"], [class*="slide-container"]',
                '.page-start, .page-end',
                // 文档：列表页图文列表容器 & 条目（文档第 5、11、21 行 DOM 示例）
                '.img-texts-list, .img-texts-item',
                // 文档：van-collapse 下展开/折叠的图文课程结构（文档第 4-10 行）
                '.van-collapse-item__content'
            ];
            const classMatchSelectors = [
                '[class*="graphic-"]',
                '[class*="page-item"]',
                '[class*="page-slide"]'
            ];
            try {
                for (const sel of indicators) {
                    try {
                        if (doc.querySelector(sel)) return true;
                    } catch (_) {}
                }
                for (const sel of classMatchSelectors) {
                    try {
                        if (doc.querySelector(sel)) return true;
                    } catch (_) {}
                }
            } catch (_) {}

            // --- 第 4 梯队：wkzy 子域图文/答题页兜底（js/item.js 加载） ---
            try {
                if (/wkzy\.mycourse\.cn$/i.test(location.hostname)) {
                    // wkzy 图文课件页：包含 item.html 常见结构
                    if (doc.querySelector('.question-content, .answer-area, .page-number') ||
                        /item\.js/i.test(doc.body ? (doc.body.innerHTML || '') : '')) {
                        return true;
                    }
                }
            } catch (_) {}

            return false;
        },

        getPageInfo(doc = document) {
            const info = {
                isCaptcha: false,
                isVideo: false,
                isGraphic: false,
                title: '',
                bodyText: ''
            };
            try {
                if (!doc) return info;

                // ========== 改进：遍历所有同源 iframe 文档综合判断 ==========
                // 学习页内容常挂载在 iframe.page-iframe 中，父级 doc 本身可能是空壳或只有 section，
                // 单看父级 doc 容易漏掉真实的 <video> 或 <canvas> 特征。
                // 因此：只要任意一个文档命中视频特征即判定为视频页；图文亦然。
                const allDocs = (typeof IframeUtils !== 'undefined' && IframeUtils.getAllIframeDocs)
                    ? IframeUtils.getAllIframeDocs()
                    : [doc];

                for (const d of allDocs) {
                    if (!d) continue;
                    try {
                        if (!info.isCaptcha && DOMUtils.isCaptcha(d)) info.isCaptcha = true;
                        if (!info.isVideo && DOMUtils.isVideo(d)) info.isVideo = true;
                        if (!info.isGraphic && DOMUtils.isGraphic(d)) info.isGraphic = true;
                        if (info.isVideo && info.isGraphic) break; // 已确定双特征，无需继续
                    } catch (_) {}
                }
                // 【互斥修正】：视频特征优先级更高（文档：视频 = video 标签；图文 = section/canvas）
                // 视频页虽然也有 section，但只要含 video 就按视频处理。
                if (info.isVideo) info.isGraphic = false;

                // 标题 & 正文（从最可能包含内容的 doc 取）
                let titleDoc = doc;
                for (const d of allDocs) {
                    if (d && d.title && d.title.length > (titleDoc ? titleDoc.title : '').length) {
                        titleDoc = d;
                    }
                }
                info.title = (titleDoc && titleDoc.title) || (doc && doc.title) || '';
                try {
                    // 【性能优化】innerText 会强制同步 reflow（每轮主循环都调用），
                    // 改用 textContent 读取纯文本，避免触发整页布局计算。
                    const bestDoc = (titleDoc && titleDoc.body) ? titleDoc : doc;
                    info.bodyText = (bestDoc && bestDoc.body && bestDoc.body.textContent ? bestDoc.body.textContent : '').substring(0, 200);
                } catch (_) {}
            } catch (e) {
                try { Logger.debug(`getPageInfo 异常: ${e.message}`); } catch (_) {}
            }

            // 尝试获取课程标题
            try {
                const titleSelectors = [
                    '.course-title', '.course-name', '.course-info h1',
                    'h1', 'h2.title', 'h2', '[class*="course-title"]',
                    '.van-ellipsis', '.van-nav-bar__title'
                ];
                const docsToScan = (typeof IframeUtils !== 'undefined' && IframeUtils.getAllIframeDocs)
                    ? IframeUtils.getAllIframeDocs()
                    : [doc];
                // 【视频课标题】默认取"挂载视频的 iframe"内第一个 h2（用户约定），
                // 优先于通用选择器，避免视频课标题显示"未知"。
                if (info.isVideo) {
                    for (const d of docsToScan) {
                        if (!d || typeof d.querySelector !== 'function') continue;
                        try {
                            const hasVideo = d.querySelector('video, .vjs-tech, .video-js, #my-video, .my-video-dimensions, .xgplayer');
                            if (!hasVideo) continue;
                            const h2 = d.querySelector('h1, h2');
                            if (h2) {
                                const txt = DOMUtils.getText(h2);
                                if (txt) { info.courseTitle = txt.substring(0, 50); break; }
                            }
                        } catch (_) {}
                    }
                }
                scanTitle:
                for (const d of docsToScan) {
                    if (!d) continue;
                    for (const sel of titleSelectors) {
                        const el = DOMUtils.query(d, sel);
                        if (el) {
                            const txt = DOMUtils.getText(el);
                            if (txt) {
                                info.courseTitle = txt.substring(0, 50);
                                break scanTitle;
                            }
                        }
                    }
                }
            } catch (e) {
                // 静默
            }

            return info;
        }
    };

    // ========== iframe 工具 ==========
    const IframeUtils = {
        getIframeDoc() {
            try {
                // ========== 根据《刷课流程解析.md》改进：iframe 内容查找 ==========
                // 文档：学习内容通过 iframe 挂载，图文有 section/canvas，视频有 video/source。
                // 原实现只匹配 .page-item/.page-slide（图文指示器），会漏掉：
                //   1) Canvas 互动图文（<canvas>，文档明确的图文特征）
                //   2) 纯 section 结构图文
                //   3) 视频 iframe（导致 video 检测只能在空壳父页面执行）
                // 改进：按优先级匹配图文 + 视频多种特征，先命中的 iframe 返回其文档。
                const iframes = document.querySelectorAll('iframe');
                const graphicSelector = '.page-item, .page-slide, canvas, section .swiper-slide, section .slider-item, [class*="graphic-"], .graphic-content, .graphic-page';
                const videoSelector = 'video, .video-js, .vjs-tech, .xgplayer, [class*="xgplayer"], .dplayer, [class*="dplayer"], #my-video, .my-video-dimensions';
                let fallbackDoc = null; // 兜底：找不到特征时返回第一个可读 iframe 的文档
                for (const iframe of iframes) {
                    try {
                        const d = iframe.contentDocument || (iframe.contentWindow && iframe.contentWindow.document);
                        if (!d || typeof d.querySelector !== 'function') continue;
                        if (!fallbackDoc) fallbackDoc = d;

                        // 优先：图文标识
                        if (d.querySelector(graphicSelector)) return d;
                        // 第二：视频标识
                        if (d.querySelector(videoSelector)) return d;
                    } catch (_) { /* 跨域或不可读，跳过 */ }
                }

                // 兜底：旧选择器
                const iframe = document.querySelector('iframe.page-iframe, iframe[class*="iframe"]');
                if (!iframe) {
                    return fallbackDoc || document;
                }
                if (!iframe.contentWindow) {
                    return fallbackDoc || document;
                }
                // 跨域访问 contentDocument 会抛错
                try {
                    return iframe.contentDocument || iframe.contentWindow?.document || fallbackDoc || document;
                } catch (_) {
                    return fallbackDoc || document;
                }
            } catch (e) {
                return document;
            }
        },

        getIframeWindow() {
            try {
                const iframe = document.querySelector('iframe.page-iframe, iframe[class*="iframe"]');
                if (!iframe) return window;
                return iframe.contentWindow || window;
            } catch (e) {
                return window;
            }
        },

        // 查找所有同源 iframe 文档
        getAllIframeDocs() {
            const docs = [document];
            try {
                const iframes = document.querySelectorAll('iframe');
                for (const iframe of iframes) {
                    try {
                        if (iframe.contentDocument) {
                            docs.push(iframe.contentDocument);
                        }
                    } catch (_) {
                        // 跨域跳过
                    }
                }
            } catch (e) {}
            return docs;
        }
    };

    // ========== 视频播放器适配器 ==========
    class VideoAdapter {
        static detect(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return null;
            // 【图文课程守卫·置于最前】页面有图文结构标记时一律不判为纯视频。
            // 必须排在任何视频检测 return 之前——否则图文课程 page-0 内嵌真实视频时，
            // 页面若含 .video-js/videojs 或 .page-WH.page-video 会在到达守卫前就
            // return 'videojs'，独立视频流程接管并提前点 back-btn 退出课程。
            try {
                if (doc.querySelector('.page-item, .page-start, .page-reciprocal, .page-end, .btn-next, .btn-aq, .btn-at, .btn-af, .btn-aq-n, .btn-aq-y')) return null;
            } catch (_) {}
            const win = (doc.defaultView && doc.defaultView.videojs !== undefined) ? doc.defaultView :
                        (doc.defaultView) ? doc.defaultView : window;

            try {
                // VideoJS
                const vjsContainer = doc.querySelector('.video-js, .vjs-tech, #my-video');
                if (vjsContainer && (win.videojs || window.videojs)) {
                    return 'videojs';
                }
                // 视频页面但 iframe 跨域无法直接访问时，仍可通过父级 .page-WH.page-video 容器识别
                if (doc.querySelector('.page-WH.page-video, section.page-WH.page-video, [class*="page-video"]')) {
                    const src = (doc.querySelector('iframe.page-iframe') || {}).src || '';
                    if (/mycourse\.cn|video/i.test(src) || doc.querySelector('iframe.page-iframe')) {
                        // 进一步识别具体播放器类型
                        if (win.videojs || window.videojs) return 'videojs';
                        if (win.xgplayer || doc.querySelector('[class*="xgplayer"]')) return 'xgplayer';
                        if (win.Hls) return 'hlsjs';
                        return 'native';
                    }
                }
                // XGPlayer (西呱播放器)
                // 新版图文模板的"空 URL xgplayer 桩"（src 为空）不算真视频
                if ((doc.querySelector('.xgplayer, #xgplayer, [class*="xgplayer"]') || win.xgplayer) && GraphicAdapter.hasRealVideoSource(doc)) {
                    return 'xgplayer';
                }
                // DPlayer
                if (win.DPlayer) return 'dplayer';
                // ArtPlayer / Artplayer
                if (win.ArtPlayer || win.artplayer) return 'artplayer';
                // CKPlayer
                if (win.ckplayer || doc.querySelector('[class*="ckplayer"]')) return 'ckplayer';
                // 微信小程序 web-view (特殊处理)
                if (doc.querySelector('web-view')) return 'webview';
                // 原生 video（需带真实源，排除空 URL 播放器桩）
                const nativeVideo = doc.querySelector('video');
                if (nativeVideo && nativeVideo.offsetParent !== null && GraphicAdapter.hasRealVideoSource(doc)) {
                    // HLS.js
                    if (win.Hls) return 'hlsjs';
                    // DASH.js
                    if (win.dash || win.MediaPlayer) return 'dash';
                    return 'native';
                }
            } catch (e) {
                try { Logger.debug(`VideoAdapter.detect 异常: ${e.message}`); } catch (_) {}
            }
            return null;
        }

        static isReady(type, player) {
            if (!player) return false;

            try {
                switch(type) {
                    case 'videojs':
                        // VideoJS: 检查播放器是否准备就绪
                        if (typeof player.ready !== 'function') return false;
                        // 检查 duration 是否可用
                        const duration = (typeof player.duration === 'function') ? player.duration() : player.duration;
                        return duration !== undefined && duration > 0;
                    case 'xgplayer':
                        return player.duration > 0;
                    case 'native':
                    case 'hlsjs':
                        return player.readyState >= 3 || player.duration > 0;
                }
            } catch (e) {
                return false;
            }
            return true;
        }

        static detectInIframe() {
            try {
                const iframe = document.querySelector('iframe.page-iframe, iframe[class*="iframe"]');
                if (!iframe) return null;

                const iframeDoc = iframe.contentDocument || iframe.contentWindow?.document;
                const iframeWin = iframe.contentWindow;
                if (!iframeDoc || !iframeWin) return null;

                // 【图文课程守卫·置于最前】同 detect：排在所有视频 return 之前，
                // 否则图文课程 iframe 内含 .video-js 时会被提前判为 videojs。
                try {
                    if (iframeDoc.querySelector('.page-item, .page-start, .page-reciprocal, .page-end, .btn-next, .btn-aq, .btn-at, .btn-af, .btn-aq-n, .btn-aq-y')) return null;
                } catch (_) {}

                // VideoJS
                const vjsContainer = iframeDoc.querySelector('.video-js');
                if (vjsContainer && iframeWin.videojs) {
                    return { type: 'videojs', doc: iframeDoc, win: iframeWin };
                }

                // XGPlayer（需带真实源，排除空 URL 播放器桩）
                if (iframeDoc.querySelector('.xgplayer, #xgplayer') && GraphicAdapter.hasRealVideoSource(iframeDoc)) {
                    return { type: 'xgplayer', doc: iframeDoc, win: iframeWin };
                }
                // 原生 video（需带真实源，排除空 URL 播放器桩）
                const nativeVideo = iframeDoc.querySelector('video');
                if (nativeVideo && nativeVideo.offsetParent !== null && GraphicAdapter.hasRealVideoSource(iframeDoc)) {
                    return { type: 'native', doc: iframeDoc, win: iframeWin };
                }
                return null;
            } catch (e) {
                // 跨域访问失败
                return null;
            }
        }

        static getPlayer(type, doc = document, iframeWin = null) {
            const win = iframeWin || window;

            switch(type) {
                case 'xgplayer':
                    // 优先从 xgplayerMap 获取实例
                    if (win.xgplayerMap) {
                        for (const key in win.xgplayerMap) {
                            if (win.xgplayerMap[key]) return win.xgplayerMap[key];
                        }
                    }
                    // 其次从 DOM 元素获取 xgplayer 实例
                    const xgEl = doc.querySelector('.xgplayer, #xgplayer, [class*="xgplayer"]');
                    if (xgEl) {
                        return xgEl.xgplayer || xgEl;
                    }
                    // 最后尝试全局 xgplayer（可能是实例对象）
                    if (win.xgplayer && typeof win.xgplayer === 'object') return win.xgplayer;
                    return null;
                case 'dplayer':
                    if (win.dp) return win.dp;
                    const dpEl = doc.querySelector('.dplayer');
                    return dpEl ? dpEl.dp : null;
                case 'artplayer':
                    if (win.art) return win.art;
                    const artEl = doc.querySelector('.artplayer');
                    return artEl ? artEl.art : null;
                case 'videojs':
                    // VideoJS: 尝试多种方式获取实例
                    // 方式1: videojs() 函数（最标准的方式）
                    if (win.videojs) {
                        // 尝试通过元素 ID 获取
                        const vjsById = win.videojs('my-video');
                        if (vjsById && typeof vjsById.play === 'function') return vjsById;

                        // 尝试通过 video-js 容器获取
                        const vjsContainer = doc.querySelector('.video-js');
                        if (vjsContainer && vjsContainer.id) {
                            const vjsByContainer = win.videojs(vjsContainer.id);
                            if (vjsByContainer && typeof vjsByContainer.play === 'function') return vjsByContainer;
                        }

                        // 尝试直接调用 videojs 选择器
                        try {
                            const vjsBySelector = win.videojs('.video-js');
                            if (vjsBySelector && typeof vjsBySelector.play === 'function') return vjsBySelector;
                        } catch (e) {}
                    }
                    // 方式2: 直接在 video 元素上获取
                    const videoEl = doc.querySelector('#my-video_html5_api, .video-js video');
                    if (videoEl && videoEl.player) {
                        return videoEl.player;
                    }
                    // 方式3: 查找 video-js 实例
                    const vjsInstance = doc.querySelector('.video-js');
                    if (vjsInstance && vjsInstance.player) {
                        return vjsInstance.player;
                    }
                    return null;
                case 'native':
                case 'hlsjs':
                    return doc.querySelector('video');
                case 'dplayer': {
                    if (win.dp) return win.dp;
                    const dpEl = doc.querySelector('.dplayer');
                    return dpEl ? dpEl.dp : null;
                }
                case 'artplayer': {
                    if (win.art) return win.art;
                    const artEl = doc.querySelector('.artplayer');
                    return artEl ? artEl.art : null;
                }
                case 'dash':
                    return doc.querySelector('video');
            }
            return null;
        }

        // 判断播放器是否暂停（兼容各播放器）
        static isPaused(type, player) {
            if (!player) return true;
            try {
                switch (type) {
                    case 'xgplayer': {
                        const v = player.videoEl || player.video || player;
                        if (v && typeof v.paused === 'boolean') return v.paused;
                        return false;
                    }
                    case 'videojs':
                        if (typeof player.paused === 'function') return player.paused();
                        if (player.video && typeof player.video.paused === 'boolean') return player.video.paused;
                        return false;
                    case 'native':
                    case 'hlsjs':
                    case 'dash':
                        return !!(player && player.paused);
                    case 'dplayer':
                        return !!(player.video && player.video.paused);
                    case 'artplayer':
                        return false;
                    default:
                        return !!(player && player.paused);
                }
            } catch (_) {
                return false;
            }
        }

        // 触发播放（兼容各播放器，忽略拒绝播放的 Promise）
        static play(type, player) {
            if (!player) return;
            try {
                switch (type) {
                    case 'xgplayer': {
                        const v = player.videoEl || player.video || player;
                        if (v && typeof v.play === 'function') v.play().catch(() => {});
                        else if (typeof player.play === 'function') player.play().catch(() => {});
                        break;
                    }
                    case 'videojs':
                        // 【video.js 6.x 兼容】play() 不返回 Promise（7.x 才返回），
                        // 直接 .catch() 会抛 TypeError 导致播放未触发；先静音（无手势自动播放必须 muted）再 play，
                        // 返回 Promise 时再 catch 静音重试。
                        if (typeof player.play === 'function') {
                            try {
                                if (typeof player.muted === 'function') player.muted(true);
                                const _p = player.play();
                                if (_p && typeof _p.catch === 'function') _p.catch(() => {});
                            } catch (_) {}
                        } else if (player.video && typeof player.video.play === 'function') {
                            try { player.video.muted = true; const _p = player.video.play(); if (_p && typeof _p.catch === 'function') _p.catch(() => {}); } catch (_) {}
                        } else {
                            try { const v0 = (document && document.querySelector) ? document.querySelector('video') : null; if (v0) { v0.muted = true; const _p = v0.play(); if (_p && typeof _p.catch === 'function') _p.catch(() => {}); } } catch (_) {}
                        }
                        break;
                    case 'native':
                    case 'hlsjs':
                    case 'dash':
                        if (typeof player.play === 'function') player.play().catch(() => {});
                        break;
                    case 'dplayer':
                        if (player.video && typeof player.video.play === 'function') player.video.play().catch(() => {});
                        break;
                    case 'artplayer':
                        if (typeof player.play === 'function') player.play().catch(() => {});
                        break;
                    default:
                        if (typeof player.play === 'function') player.play().catch(() => {});
                        break;
                }
            } catch (_) {}
        }

        // 统一设置播放倍速（真实播放模式下用 2x 真实播放，不做进度跳转）
        static applyRate(type, player, rate) {
            if (!player) return false;
            try {
                switch (type) {
                    case 'xgplayer': {
                        const v = player.videoEl || player.video || player;
                        if (v && v.tagName === 'VIDEO') v.playbackRate = rate;
                        try { if (typeof player.playbackRate !== 'undefined') player.playbackRate = rate; } catch (_) {}
                        return true;
                    }
                    case 'videojs': {
                        if (typeof player.playbackRate === 'function') { player.playbackRate(rate); return true; }
                        if (player.video) { try { player.video.playbackRate = rate; } catch (_) {} return true; }
                        const v0 = (document && document.querySelector) ? document.querySelector('video') : null;
                        if (v0) { v0.playbackRate = rate; return true; }
                        return false;
                    }
                    case 'native':
                    case 'hlsjs':
                    case 'dash':
                        player.playbackRate = rate;
                        return true;
                    case 'dplayer':
                        if (player.video) { player.video.playbackRate = rate; return true; }
                        return false;
                    case 'artplayer':
                        try { player.playbackRate = rate; } catch (_) {}
                        return true;
                    default:
                        if (player.playbackRate !== undefined) { player.playbackRate = rate; return true; }
                        return false;
                }
            } catch (_) {
                return false;
            }
        }

        static complete(type, player) {
            if (!player) {
                Logger.debug('VideoAdapter.complete: player is null');
                return;
            }

            try {
                switch(type) {
                    case 'xgplayer':
                        if (player.muted) player.muted(true);
                        if (player.paused) player.play().catch(() => {});
                        const xgVideoEl = player.videoEl || player.video || player;
                        if (xgVideoEl.duration && xgVideoEl.duration > 0) {
                            xgVideoEl.currentTime = xgVideoEl.duration - 0.5;
                        }
                        break;
                    case 'videojs':
                        // VideoJS 特殊处理
                        if (typeof player.muted === 'function') {
                            player.muted(true);
                        } else {
                            // 如果 muted 不是函数，尝试直接设置
                            try { player.muted = true; } catch(e) {}
                        }
                        // 点击播放按钮（如果存在且视频暂停）
                        const bigPlayBtn = document.querySelector('.vjs-big-play-button');
                        if (bigPlayBtn && bigPlayBtn.offsetParent !== null) {
                            DOMUtils.simulateClick(bigPlayBtn);
                        }
                        // 跳转到接近结尾
                        if (typeof player.currentTime === 'function' && typeof player.duration === 'function') {
                            const duration = player.duration();
                            if (duration > 0) {
                                player.currentTime(duration - 0.5);
                            }
                        } else if (player.duration && player.duration > 0) {
                            // 直接属性访问
                            player.currentTime = player.duration - 0.5;
                        }
                        // 播放（【video.js 6.x 兼容】play() 不返回 Promise，不能直接 .catch）
                        if (typeof player.play === 'function') {
                            try {
                                const _p = player.play();
                                if (_p && typeof _p.catch === 'function') {
                                    _p.catch(e => {
                                        try { const _p2 = player.play(); if (_p2 && typeof _p2.catch === 'function') _p2.catch(() => {}); } catch (e2) {}
                                    });
                                }
                            } catch (_) {}
                        }
                        break;
                    case 'native':
                    case 'hlsjs':
                    case 'dash':
                        player.muted = true;
                        if (player.duration > 0) {
                            player.currentTime = player.duration - 0.5;
                            player.play().catch(() => {});
                        }
                        break;
                    case 'dplayer':
                        if (player.muted) player.muted(true);
                        if (player.paused) player.play().catch(() => {});
                        if (player.video && player.video.duration > 0) {
                            player.seek(player.video.duration - 0.5);
                        }
                        break;
                    case 'artplayer':
                        if (player.muted) player.muted(true);
                        if (player.paused) player.play().catch(() => {});
                        if (player.duration && player.duration > 0) {
                            player.seek(player.duration - 0.5);
                        }
                        break;
                }
            } catch (e) {
                Logger.debug(`VideoAdapter.complete error: ${e.message}`);
            }
        }

        static isCompleted(type, player) {
            if (!player) return false;

            let current = 0, total = 0;
            try {
                switch(type) {
                    case 'dplayer':
                        current = player.video?.currentTime || 0;
                        total = player.video?.duration || 0;
                        return player.ended || (total > 0 && ((total - current) <= 2 || current / total >= 0.995));
                    case 'artplayer':
                        current = player.currentTime || 0;
                        total = player.duration || 0;
                        return player.ended || (total > 0 && ((total - current) <= 2 || current / total >= 0.995));
                    case 'dash':
                        if (player.ended) return true;
                        current = player.currentTime || 0;
                        total = player.duration || 0;
                        return total > 0 && ((total - current) <= 2 || current / total >= 0.995);
                    case 'xgplayer':
                        // xgplayer 实例属性在 player.videoEl 上
                        const xgVideo = player.videoEl || player.video || player;
                        current = xgVideo.currentTime || player.currentTime || 0;
                        total = xgVideo.duration || player.duration || 0;
                        break;
                    case 'videojs':
                        // VideoJS 使用函数调用
                        if (typeof player.currentTime === 'function' && typeof player.duration === 'function') {
                            current = player.currentTime();
                            total = player.duration();
                        } else if (player.currentTime !== undefined && player.duration !== undefined) {
                            // 直接属性
                            current = player.currentTime;
                            total = player.duration;
                        }
                        // 【video.js 6.x 兼容】player.ended 是方法（truthy），不能直接当布尔用，
                        // 必须 player.ended() 调用（7.x 同为方法）。
                        const _vjsEnded = (typeof player.ended === 'function') ? !!player.ended() : !!player.ended;
                        // 【真实播放守卫】暂停且未播完时不判完成：
                        // 短视频/加载初期 current 可能已 ≥1 且 duration-current≤2（会被下方总判断误判为"完成"），
                        // 但视频实际处于暂停（未真正播放）。真实模式下必须真的播放到接近结尾才算完成。
                        // 已播完（current≥total）或 ended 时不拦截。
                        if (CONFIG.realVideoPlay && typeof player.paused === 'function' && player.paused()
                            && !_vjsEnded
                            && (!isFinite(total) || current < total)) {
                            return false;
                        }
                        // 检查 ended 状态（videojs 的 ended 是方法，须调用判断）
                        if (_vjsEnded) {
                            return true;
                        }
                        // 检查 vjs-ended 类（VideoJS 播放结束标记）
                        const vjsContainer = document.querySelector('.video-js');
                        if (vjsContainer && vjsContainer.classList.contains('vjs-ended')) {
                            return true;
                        }
                        // 检查播放控件状态（replay 按钮出现表示结束）
                        const playControl = document.querySelector('.vjs-play-control.vjs-ended');
                        if (playControl) {
                            return true;
                        }
                        break;
                    case 'native':
                    case 'hlsjs':
                    case 'dash':
                        current = player.currentTime;
                        total = player.duration;
                        if (player.ended !== undefined && player.ended) {
                            return true;
                        }
                        break;
                }
            } catch (e) {
                Logger.debug(`isCompleted error: ${e.message}`);
            }

            if (!total || total <= 0) return false;
            // 【真实播放守卫】current 为 0（尚未实际播放）时不判完成：
            // videojs/HLS 加载初期 duration 可能短暂为很小值（≤2s），此时 total-current≤2 会误判"已完成"，
            // 导致视频刚进入就触发 handleVideoComplete（表现为"视频播放时间仅几 ms 即完成"并提前退出课程）。
            // 快速模式 complete() 已把 current 拉到结尾附近（>1），不受此守卫影响。
            if (!(current >= 1)) return false;
            // 【HLS duration 虚低守卫】current 明显超过 total（>2s）说明 duration 不可信：
            // videojs contrib-hls 加载中 duration() 可能报片段时长/短暂异常（如真实 60s 报 3s），
            // 此时 total-current≤2 或 current/total≥0.995 会恒真误判"已完成"，
            // 导致视频刚播几秒就触发完成并提前跳走。真实播放必须等到 ended 或 current 接近真实结尾。
            if (isFinite(current) && isFinite(total) && total > 0 && current > total + 2) {
                return false;
            }
            // 无论真实播放还是快速跳过，都要求播放到接近结尾（剩余 ≤2s 或 ≥99.5%）才算完成，
            // 保证 100% 完整完成（站点按完整播放记录进度）；快速模式已跳到结尾附近，不会卡住。
            return (total - current) <= 2 || (current / total) >= 0.995;
        }

        static getProgress(type, player) {
            if (!player) return 0;
            let current = 0, total = 0;
            try {
                switch(type) {
                    case 'xgplayer':
                        // xgplayer 实例属性在 player.videoEl 上
                        const xgVideo = player.videoEl || player.video || player;
                        current = xgVideo.currentTime || player.currentTime || 0;
                        total = xgVideo.duration || player.duration || 0;
                        break;
                    case 'videojs':
                        if (typeof player.currentTime === 'function' && typeof player.duration === 'function') {
                            current = player.currentTime();
                            total = player.duration();
                        } else if (player.currentTime !== undefined && player.duration !== undefined) {
                            current = player.currentTime;
                            total = player.duration;
                        }
                        break;
                    case 'native':
                    case 'hlsjs':
                    case 'dash':
                        current = player.currentTime;
                        total = player.duration;
                        break;
                    case 'dplayer':
                        current = player.video?.currentTime || 0;
                        total = player.video?.duration || 0;
                        break;
                    case 'artplayer':
                        current = player.currentTime || 0;
                        total = player.duration || 0;
                        break;
                }
            } catch (e) {}
            const _p = total > 0 ? (current / total) * 100 : 0;
            return Math.min(100, Math.max(0, _p));
        }

        // 格式化时间为 mm:ss 格式
        static formatTime(seconds) {
            if (!seconds || isNaN(seconds)) return '00:00';
            const mins = Math.floor(seconds / 60);
            const secs = Math.floor(seconds % 60);
            return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
        }
    }

    // ========== 图文页面处理 ==========
    class GraphicAdapter {
        /**
         * 模糊匹配“下一页”按钮的 class / src。
         * 将 - _ 空格以及驼峰边界统一归一化，使 btn-next / btn_next / btnNext / btnnext /
         * next-btn / next_btn / nextBtn / nextbtn / page-next / pageNext 等变体全部命中。
         * 纯 "next"（无 btn/page 语境）不命中，避免误判普通文本。
         */
        static fuzzyNextClass(value) {
            if (!value) return false;
            const norm = String(value)
                .replace(/([a-z0-9])([A-Z])/g, '$1·$2')   // 驼峰边界：btnNext → btn·Next
                .toLowerCase()
                .replace(/[-_\s]+/g, '·');               // 分隔符统一为 ·（- _ 空格）
            return /(?:^|·)btn·?next/.test(norm)    // btn-next / btn_next / btnNext / btnnext / x·btn-next
                || /(?:^|·)next·?btn/.test(norm)    // next-btn / next_btn / nextBtn / nextbtn
                || /(?:^|·)page·?next/.test(norm);  // page-next / pageNext / page_next
        }

        // 在指定容器内查找下一页按钮：CSS 快速路径 + 模糊兜底
        static findNextIn(root) {
            if (!root || typeof root.querySelector !== 'function') return null;
            // 快速路径：常见 class 形态
            try {
                const fast = root.querySelector('.btn-next, [class*="btn-next"]:not([class*="prev"]), [class*="next-btn"]:not([class*="prev"]):not([class*="page-next"]), [class*="next_btn"]:not([class*="prev"]), [class*="btn_next"]:not([class*="prev"]), a.btn-next img');
                if (fast) return fast;
            } catch (_) {}
            // 模糊兜底：大小写不敏感 + 归一化匹配（覆盖 btnNext / nextBtn / btn_next / pageNext 等）
            try {
                const candidates = root.querySelectorAll('[class*="next" i]');
                for (const el of candidates) {
                    if (!el || el.nodeType !== 1) continue;
                    const cls = el.className || '';
                    if (/prev|back|返回|上/.test(cls)) continue;
                    if (!GraphicAdapter.fuzzyNextClass(cls)) continue;
                    return el;
                }
            } catch (_) {}
            return null;
        }

        // 查找开始按钮
        static findStartButton(doc = document, scope = null) {
            if (!doc || typeof doc.querySelector !== 'function') return null;
            try {
                const searchRoot = scope || doc;
                // 关键防御：searchRoot 自身是 .page-item（特别是 .page-start.page-active）
                // 时，宽松的 [class*="page-start"] 等选择器会把容器自身误判为按钮。
                // 必须显式排除 searchRoot 自身及其祖先，避免"点了 activeSection 自身"导致
                // hasClickedStart 被置为 true 但页面永远不切换的死锁。
                const isContainerSelfOrAncestor = (el) => {
                    if (!el) return false;
                    let cur = el;
                    while (cur) {
                        if (cur === searchRoot) return true;
                        cur = cur.parentElement || null;
                    }
                    return false;
                };

                // 优先级：精确匹配 > 含 class 关键词 > 文本内容
                const selectors = [
                    // 1) 精确匹配
                    'a.btn-start',
                    'a.an-position.btn-start',
                    // 2) 含 btn-start class 的任意标签
                    '[class*="btn-start"]',
                    // 3) 含 start-lear class
                    '[class*="start-lear"]',
                    '[class*="start_lear"]',
                    // 4) page-start-btn / start_btn 等模糊匹配（命中 <span class="page-content-common page-start-btn"></span>）
                    '[class*="start-btn"]',
                    '[class*="start_btn"]',
                    // 5) an-position 定位层中的 a 标签
                    'a.an-position',
                    // 6) img 标签（含 btn-start、pstart、pnext 等）
                    'img[src*="btn-start"]',
                    'img[src*="btn_start"]',
                    'img[src*="start-btn"]',
                    'img[src*="start_btn"]',
                    'img[class*="btn-start"]',
                    'img[class*="start-btn"]',
                    'img[class*="start_btn"]',
                    'img.an-position',
                    // 7) 任意可见 img 元素兜底
                    'img.element',
                    'img.element[class*="btn"]',
                    'img.btn-next',
                    // 8) 文本含"开始"的 button
                    'button[class*="start"]',
                    'a[class*="start"]'
                ];

                for (const sel of selectors) {
                    try {
                        let btn = searchRoot.querySelector(sel);
                        if (!btn) continue;

                        // IMG → 找可点击父级
                        if (btn.tagName === 'IMG') {
                            const parent = btn.closest('a, button, div[onclick], [role="button"], .an-position');
                            if (parent) btn = parent;
                        }

                        // 过滤：searchRoot 自身或祖先（防止 .page-start 容器自身被误判为按钮）
                        if (isContainerSelfOrAncestor(btn)) continue;

                        // 过滤：禁用 / display:none 跳过（非 display:none 但 offsetParent 为 null 的仍尝试）
                        if (btn.disabled) continue;

                        // 验证：匹配文本或关键 class（精确关键字，避免被 page-start 的 "start" 命中）
                        const cls = btn.className || '';
                        const txt = (btn.textContent || '').trim();
                        const src = btn.tagName === 'IMG' ? (btn.getAttribute('src') || '') : '';
                        const isStart =
                            /btn-start|start-btn|start_btn|start-lear|start_lear|进入|btn_start/.test(cls) ||
                            /btn-start|start-btn|start_btn|btn_start/.test(src) ||
                            /开始学习|开始|进入学习/.test(txt);
                        if (!isStart) continue;

                        // 额外安全网：拒绝 page-start / page-end 这种"占位 section"被当按钮
                        // 但当元素 className 明确包含 btn-start（用户强需求：只要 class 带 btn-start 就点）
                        // 时，不再被 page-start 容器自身过滤；只有当元素本身就是 page-start 占位 section
                        // 且没有 btn-start 标记时才拒绝
                        const hasBtnStartCls = /(^|\s)btn-start(\s|$)/.test(cls)
                            || /btn-start/.test(cls); // 兼容 className 拼接场景
                        if (!hasBtnStartCls && /^page-(start|end)\b/.test(cls.trim())) continue;

                        try { Logger.debug(`findStartButton 命中: ${sel} → ${cls.substring(0, 40)}`); } catch (_) {}
                        return btn;
                    } catch (e) {}
                }

                // 兜底 1：遍历所有 a 标签（用于非标准 class 命名）
                try {
                    const allLinks = searchRoot.querySelectorAll('a');
                    for (const a of allLinks) {
                        if (isContainerSelfOrAncestor(a)) continue;
                        const txt = (a.textContent || '').trim();
                        const cls = a.className || '';
                        const matchesText = /开始学习|开始|进入学习|开始按钮/.test(txt);
                        const matchesCls = /btn-start|start-btn|start_btn|start-lear|start_lear|btn_start/.test(cls)
                            || /an-position/.test(cls);
                        if ((matchesText || matchesCls) && !/prev|back|返回|关闭|取消/.test(cls)) {
                            try { Logger.debug(`findStartButton 兜底命中: ${a.href || cls}`); } catch (_) {}
                            return a;
                        }
                    }
                } catch (e) {}

                // 兜底 2：遍历所有 button / span / div 标签（兼容 page-start-btn / start_btn 等命名）
                try {
                    const allBtns = searchRoot.querySelectorAll('button, span, div');
                    for (const b of allBtns) {
                        if (isContainerSelfOrAncestor(b)) continue;
                        // 额外安全网：拒绝 .page-start / .page-end 这种"占位 section"被当按钮
                        const bcls = (b.className || '').trim();
                        if (/^page-(start|end)\b/.test(bcls) || /\bpage-(start|end)\b/.test(bcls)) continue;
                        const txt = (b.textContent || '').trim();
                        const cls = b.className || '';
                        const matchesText = /开始学习|开始|进入学习/.test(txt);
                        const matchesCls = /btn-start|start-btn|start_btn|start-lear|start_lear/.test(cls);
                        if ((matchesText || matchesCls)
                            && !/prev|back|返回|关闭|取消|next|btn-next|next-btn|next_btn/.test(cls)) {
                            try { Logger.debug(`findStartButton 标签兜底命中: ${b.tagName} ${cls}`); } catch (_) {}
                            return b;
                        }
                    }
                } catch (e) {}
            } catch (e) {
                try { Logger.debug(`findStartButton 异常: ${e.message}`); } catch (_) {}
            }
            return null;
        }

        // 点击开始按钮（处理 img 元素）
        static clickStartButton(btn) {
            if (!btn) return false;
            try {
                const fireClick = (target) => {
                    if (!target) return false;
                    let ok = false;
                    // 1) 派发完整 Pointer/Mouse/click 事件序列（触发原生监听器）
                    try { ok = DOMUtils.simulateClick(target) || ok; } catch (_) {}
                    // 2) 对带 btn-start 类的元素做激进兜底：jQuery 监听器需要原生 click 事件
                    //    这里额外派发一次原生 click，避免某些页面因为 e.preventDefault 链断了导致不响应
                    try {
                        const tCls = (target.className || '') + ' ' + (target.getAttribute && target.getAttribute('href') || '');
                        if (/btn-start|start-btn|start_btn|btn_start/.test(tCls)) {
                            // 2a) 再次派发一个 cancelable:false 的 click（部分站点只在 defaultPrevented=false 时处理）
                            try {
                                target.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: false, view: window, button: 0 }));
                            } catch (_) {}
                            // 2b) jQuery 兜底：trigger('click') 能确保绑定的 jQuery handler 被执行
                            try {
                                const $ = (typeof window !== 'undefined') ? window.jQuery : null;
                                if ($ && typeof target === 'object' && target.nodeType === 1) {
                                    try { $(target).trigger('click'); ok = true; } catch (_) {}
                                }
                            } catch (_) {}
                            // 2c) 直接调用原生 .click()（同步触发，绕过 dispatchEvent 的某些限制）
                            try { if (typeof target.click === 'function') { target.click(); ok = true; } } catch (_) {}
                            // 2d) 兜底：a 标签的 href="javascript:;" 需要 click 触发后执行，
                            //     对带 href 的 a 标签额外触发一次 focus + click
                            try {
                                if (target.tagName === 'A' && target.getAttribute && target.getAttribute('href')) {
                                    try { target.focus && target.focus(); } catch (_) {}
                                    try { target.click(); ok = true; } catch (_) {}
                                }
                            } catch (_) {}
                        }
                    } catch (_) {}
                    return ok;
                };

                if (btn.tagName === 'IMG') {
                    const parent = btn.closest('a, button, div[onclick], [role="button"], .an-position') || btn.parentElement;
                    if (parent) fireClick(parent);
                    // 同时也尝试点击原始 IMG，部分站点只监听 IMG 的 mousedown
                    if (parent !== btn) fireClick(btn);
                } else {
                    fireClick(btn);
                }
                try { Logger.debug(`clickStartButton → ${btn.tagName} ${(btn.className||'').substring(0,30)}`); } catch (_) {}
            } catch (e) {
                try { Logger.error('点击开始按钮失败', e); } catch (_) {}
            }
            return true;
        }

        // 获取当前页码
        static getCurrentPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return null;
            try {
                const activePage = doc.querySelector('.page-item.page-active, [class*="page-item"][class*="active"], section.page-active');
                if (activePage) {
                    const classes = (activePage.className || '').split(/\s+/);
                    for (const cls of classes) {
                        const numMatch = cls.match(/^page-(\d+)$/);
                        if (numMatch) {
                            return parseInt(numMatch[1], 10);
                        }
                        const alphaMatch = cls.match(/^page-([a-z]+)(\d+)$/);
                        if (alphaMatch) {
                            return cls;
                        }
                    }
                }
                let sections = doc.querySelectorAll('.page-item');
                if (!sections || sections.length === 0) {
                    try { sections = doc.querySelectorAll('[class^="page-"]'); } catch (_) {}
                }
                for (let i = 0; i < sections.length; i++) {
                    if (sections[i].classList.contains('page-active')) {
                        return i;
                    }
                }
            } catch (e) {
                try { Logger.debug(`getCurrentPage 异常: ${e.message}`); } catch (_) {}
            }
            return null;
        }

        // 判断是否为最后一页
        static isLastPage(doc = document) {
            if (!doc || typeof doc.querySelectorAll !== 'function') return false;
            try {
                // 优先检测 page-end-back 元素（课程结束标记）——必须是【可见】的，
                // 否则 DOM 中提前渲染的隐藏结束页按钮会把中间页误判为已结束
                const endBackBtn = doc.querySelector('.page-end-back, [class*="page-end-back"]');
                if (endBackBtn && DOMUtils.isVisible(endBackBtn)) {
                    return true;
                }

                const sections = doc.querySelectorAll('.page-item');
                if (sections.length === 0) {
                    // 新版编号页模板（btn-aq-n）：无 .page-item，退回编号页/起止页
                    try {
                        const alt = GraphicJsAdapter.pageItems(doc);
                        if (!alt.length) return false;
                        const activeAlt = GraphicJsAdapter.activePage(doc);
                        if (!activeAlt) return false;
                        if (activeAlt.classList && (activeAlt.classList.contains('page-end') || activeAlt.classList.contains('page-reciprocal'))) return true;
                        // 页码判定：活跃页码 >= 最大页码视为末页
                        let maxNum = -1;
                        for (const s of alt) {
                            let c = '';
                            try { c = String(s.className != null ? s.className : ''); } catch (_) {}
                            if (!c) { try { c = String(s.getAttribute ? s.getAttribute('class') || '' : ''); } catch (_) {} }
                            const m = c.match(/(^|\s)page-(\d+)(\s|$)/);
                            if (m) maxNum = Math.max(maxNum, parseInt(m[2], 10));
                        }
                        let ac = '';
                        try { ac = String(activeAlt.className != null ? activeAlt.className : ''); } catch (_) {}
                        const am = ac.match(/(^|\s)page-(\d+)(\s|$)/);
                        if (am && maxNum >= 0) return parseInt(am[2], 10) >= maxNum;
                        return false;
                    } catch (_) { return false; }
                }
                const activePage = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!activePage) return false;
                if (activePage.classList && activePage.classList.contains('page-end')) return true;
                // 【硬守卫2】活跃页内存在【可见的 btn-ce（课后问答入口按钮）】→ 必然不是末页。
                // 根治"page-19 btn-ce 页被当末页 → 跳过课后问答 → 课程不完整触发风控"。
                // 用户 JS: BtnFn(".btn-ce", ".page-19", ".page-aq00") —— btn-ce 点击进入 page-aq00 问答。
                try {
                    let hasVisibleBtnCe = false;
                    activePage.querySelectorAll('[class*="btn-ce" i]').forEach(el => {
                        if (hasVisibleBtnCe) return;
                        try {
                            if (typeof el.getClientRects === 'function' && el.getClientRects().length > 0) hasVisibleBtnCe = true;
                        } catch (_) {}
                    });
                    if (hasVisibleBtnCe) return false;
                } catch (_) {}
                // 【硬守卫】活跃页内存在【可见的纯 btn-next】→ 必然不是末页。
                // 根治本站"第 8 页误判图文完成"：结束页不会再有下一页按钮。
                // 用大小写不敏感选择器覆盖驼峰变体，归一化后仅认 btn·next / next·btn 家族（不含 page-next 容器）。
                try {
                    let hasVisiblePlainNext = false;
                    activePage.querySelectorAll('[class*="next" i]').forEach(el => {
                        if (hasVisiblePlainNext) return;
                        const cls = el.className || '';
                        const norm = cls.toLowerCase().replace(/[-_\s]+/g, '·');
                        const isBtnNext = /(?:^|·)btn·?next/.test(norm) || /(?:^|·)next·?btn/.test(norm);
                        if (!isBtnNext) return;
                        if (/btn·?next\d|next·?btn\d/.test(norm)) return; // 排除 btn-next26 等编号叠加层
                        try {
                            if (typeof el.getClientRects === 'function' && el.getClientRects().length > 0) {
                                hasVisiblePlainNext = true;
                            }
                        } catch (_) {}
                    });
                    if (hasVisiblePlainNext) return false;
                } catch (_) {}
                // 【硬守卫3】活跃页之后（DOM 顺序）还有"页码数字内容页"（page-N，非问答/结束页）→ 必然不是末页。
                // 根治"评论区 page-20 页码最大但实际是中间页"误判：本站评论区页可插在中间
                // （DOM 顺序 ...page-15, page-20(评论区), page-16(选择框), page-17(btn-ce 问答入口)...），
                // 若仅按"活跃页码 >= 最大页码"判断，page-20 会被误判为末页 → 跳过后续选择/问答/课后题直接完成。
                try {
                    const _secIdx = Array.from(sections).indexOf(activePage);
                    if (_secIdx >= 0) {
                        for (let _i = _secIdx + 1; _i < sections.length; _i++) {
                            const _cls = String(sections[_i].className || '');
                            if (/\bpage-(aq|af)\d+\b/.test(_cls)) continue; // 跳过问答/答错页
                            if (/\bpage-end\b/.test(_cls)) break;              // 遇到结束页：后续无内容
                            if (/\bpage-start\b/.test(_cls)) continue;
                            if (/(^|\s)page-(\d+)(\s|$)/.test(_cls)) return false; // 后面还有 page-N 内容页
                        }
                    }
                } catch (_) {}
                // 用页码类（page-N）判断：活跃页码 >= DOM 中最大页码才视为末页，
                // 避免 NodeList 数量与真实页数不一致导致"中途误判最后一页"
                let maxNum = -1;
                for (const s of sections) {
                    const m = String(s.className || '').match(/(^|\s)page-(\d+)(\s|$)/);
                    if (m) maxNum = Math.max(maxNum, parseInt(m[2], 10));
                }
                const am = String(activePage.className || '').match(/(^|\s)page-(\d+)(\s|$)/);
                if (am && maxNum >= 0) {
                    return parseInt(am[2], 10) >= maxNum;
                }
                // 兜底：索引判断（兼容无 page-N 命名的站点）
                const idx = Array.from(sections).indexOf(activePage);
                return idx === sections.length - 1;
            } catch (e) {}
            return false;
        }

        // 判断是否到达结束页
        static isEndPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                // 优先检测 page-end-back 元素（课程结束标记）——同样要求可见，避免隐藏结束页误判
                const endBackBtn = doc.querySelector('.page-end-back, [class*="page-end-back"]');
                if (endBackBtn && DOMUtils.isVisible(endBackBtn)) {
                    return true;
                }

                const activePage = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (activePage) {
                    return activePage.classList.contains('page-end');
                }
            } catch (e) {}
            return false;
        }

        static getTotalPages(doc = document) {
            if (!doc || typeof doc.querySelectorAll !== 'function') return 0;
            try {
                const pageItems = doc.querySelectorAll('.page-item');
                if (pageItems.length > 0) return pageItems.length;

                const selectors = [
                    '[class*="page-"]',
                    '[data-page]',
                    '.swiper-pagination-bullet',
                    '.indicator-item'
                ];
                for (const sel of selectors) {
                    const items = doc.querySelectorAll(sel);
                    if (items.length > 0) return items.length;
                }
            } catch (e) {}
            return 0;
        }

        // 获取当前活跃 page-item 的稳定标识
        // 用于"按钮已触发 + 页面已切换"的判定
        static getActiveSectionId(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return null;
            try {
                const active = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!active) return null;
                let idx = -1;
                try { idx = Array.from(doc.querySelectorAll('.page-item')).indexOf(active); } catch (_) {}
                if (idx === -1) idx = Array.from(doc.querySelectorAll('[class^="page-"]')).indexOf(active);
                const classes = (active.className || '').trim();
                const rect = active.getBoundingClientRect();
                // 用 index + class + 位置 拼出稳定标识
                return `${idx}|${classes}|${Math.round(rect.top)}|${Math.round(rect.left)}`;
            } catch (_) {}
        }

        // 按索引取 section 的稳定标识（翻页验证用：翻页前记录"翻页前页面"的 id，
        // 验证时与当前 active 对比 → hasPageTurned 才能判定"页面确实切换"）。
        static getSectionIdByIndex(doc, idx) {
            if (!doc || typeof doc.querySelectorAll !== 'function' || idx == null || idx < 0) return null;
            try {
                const all = doc.querySelectorAll('.page-item, [class^="page-"]');
                const el = all && all[idx];
                if (!el) return null;
                const classes = (el.className || '').trim();
                let rect = { top: 0, left: 0 };
                try { rect = el.getBoundingClientRect(); } catch (_) {}
                return `${idx}|${classes}|${Math.round(rect.top)}|${Math.round(rect.left)}`;
            } catch (_) { return null; }
        }

        // 统一模拟点击入口：先尝试派发完整 Pointer/Mouse/click 序列，
        // 若站点依赖 hover/focus，再补充 hover/focus。返回是否派发成功。
        static simulateClick(el, opts = {}) {
            if (!el) return false;
            return DOMUtils.simulateClick(el, opts);
        }

        // 检测是否可以触发翻页：页面还未真正切换前不重复触发
        static canTriggerPageTurn(doc = document, cooldownMs = 0) {
            if (!State.isPageTurning) return true;
            if (cooldownMs > 0 && State.pageTurnTriggerTime) {
                const elapsed = Date.now() - State.pageTurnTriggerTime;
                if (elapsed >= cooldownMs) {
                    // 超时强制解锁，避免卡死
                    State.isPageTurning = false;
                    State.pageTurnTriggerTime = null;
                    State.pageTurnTriggerSelector = null;
                    return true;
                }
            }
            return false;
        }

        // 标记翻页已触发；记录 trigger 时间和描述，用于后续判断是否真正切换
        static markPageTurnTriggered(selector = '') {
            State.isPageTurning = true;
            State.pageTurnTriggerTime = Date.now();
            State.pageTurnTriggerSelector = selector;
            try {
                State.lastActiveSectionId = this.getActiveSectionId(document);
            } catch (_) {}
        }

        // 翻页是否真正完成（page-active 已切到下一项）
        static hasPageTurned(doc = document) {
            try {
                const newId = this.getActiveSectionId(doc);
                if (!newId || !State.lastActiveSectionId) return false;
                return newId !== State.lastActiveSectionId;
            } catch (_) {
                return false;
            }
        }

        // 释放翻页锁定（成功 / 超时均调用）
        static clearPageTurnLock() {
            State.isPageTurning = false;
            State.pageTurnTriggerTime = null;
            State.pageTurnTriggerSelector = null;
        }

        // ========== 三级翻页优先级（完全对齐站点 build JS）==========
        // Tier1(最高)：读取课程 build JS 检测翻页函数 → 触发站点 .btn-next handler（调用函数翻页）
        // Tier2(兜底)：检测不到/无按钮 → 直接给下一个 section 加 page-active class（确定性切页）
        // Tier3(最后)：class 模糊匹配（findNextButton / [btn-next 兜底]）
        // 依据 A11081.js：$(".btn-next").click(...) → _nextPage() 移动 .page-active 到下一兄弟，
        //                 末页 .page-end 激活时自动调 finishWxCourse()；btn_timer=1200ms 节流。
        static flipJsCache = null; // { courseId, data, ts }
        static _flipJsReading = false;

        static deriveCourseId() {
            try {
                const m = window.location.pathname.match(/\/course\/([^/]+)\//);
                if (m && m[1]) return m[1];
            } catch (_) {}
            return null;
        }

        // 后台异步读取 build JS 并缓存检测结果（不阻塞主循环；未读到时默认按 .btn-next 机制处理）
        static ensureFlipJsRead() {
            try {
                const courseId = GraphicAdapter.deriveCourseId();
                if (!courseId) return;
                if (GraphicAdapter.flipJsCache && GraphicAdapter.flipJsCache.courseId === courseId) return;
                if (GraphicAdapter._flipJsReading) return;
                GraphicAdapter._flipJsReading = true;
                setTimeout(() => {
                    GraphicAdapter.readFlipJs().finally(() => { GraphicAdapter._flipJsReading = false; });
                }, 0);
            } catch (_) {}
        }

        static async readFlipJs() {
            const courseId = GraphicAdapter.deriveCourseId();
            if (!courseId) return null;
            try {
                const url = `https://mcwk.mycourse.cn/course/${courseId}/build/js/${courseId}.js?ts=${Date.now()}`;
                const text = await new Promise((resolve) => {
                    try {
                        GM_xmlhttpRequest({
                            method: 'GET', url: url, responseType: 'text',
                            onload: (r) => resolve(r.responseText || ''),
                            onerror: () => resolve('')
                        });
                    } catch (_) { resolve(''); }
                });
                if (!text) return null;
                const data = {
                    courseId: courseId,
                    btnNext: /\.btn-next/.test(text) && /\.click\s*\(/.test(text),
                    pageActiveNext: /page-active/.test(text) && /\.next\s*\(/.test(text),
                    finishWx: /finishWxCourse/.test(text),
                    pageStartBtn: /\.page-start-btn/.test(text),
                    pageEnd: /\.page-end/.test(text),
                    btnTimer: (() => { const m = text.match(/btn_timer\s*=\s*(\d+)/); return m ? parseInt(m[1], 10) : null; })()
                };
                GraphicAdapter.flipJsCache = { courseId: courseId, data: data, ts: Date.now() };
                try { Logger.info(`[JS检测] ${courseId}.js 解析完成: btnNext=${data.btnNext} pageActiveNext=${data.pageActiveNext} finishWx=${data.finishWx} btn_timer=${data.btnTimer}`); } catch (_) {}
                return data;
            } catch (_) { return null; }
        }

        // 判定元素是否为可用的下一页按钮（可见、非禁用、非 prev、非编号叠加层、非 page-next 容器）
        static isUsableNext(el) {
            try {
                if (!el || el.nodeType !== 1) return false;
                if (el.disabled) return false;
                const cls = String(el.className || '');
                if (/(^|\s)(prev|previous|back)(\s|-|$)/.test(cls.toLowerCase())) return false;
                // 编号叠加层（btn-next26 / next_btn3 等）：点击会导致课程进度被重置回中间页，排除
                const norm = cls.replace(/([a-z0-9])([A-Z])/g, '$1·$2').toLowerCase().replace(/[-_\s]+/g, '·');
                if (/btn·?next\d|next·?btn\d/.test(norm)) return false;
                // page-next 容器（非按钮，是承载区）
                if (/(?:^|·)page·?next/.test(norm) && !/(?:^|·)btn·?next/.test(norm) && !/(?:^|·)next·?btn/.test(norm)) return false;
                if (typeof el.getClientRects === 'function' && el.getClientRects().length === 0) return false;
                try { if (getComputedStyle(el).visibility === 'hidden') return false; } catch (_) { return false; }
                return true;
            } catch (_) { return false; }
        }

        // Tier1：读取 JS 检测 + 调用站点 .btn-next 函数翻页（同步；检测结果由 ensureFlipJsRead 异步预取）
        // 返回 { clicked, reason }：clicked=true 表示已触发站点翻页函数（等同站点 _nextPage + finishWxCourse 链路）
        static turnPageByJs(doc = document) {
            GraphicAdapter.ensureFlipJsRead();
            try {
                const det = GraphicAdapter.flipJsCache ? GraphicAdapter.flipJsCache.data : null;
                // JS 明确检测到非 .btn-next 机制时才放弃 Tier1（默认按标准 .btn-next 机制）
                if (det && det.btnNext === false && det.pageActiveNext === false) {
                    return { clicked: false, reason: 'js-says-not-btnnext' };
                }
                const sel = '.btn-next, [class*="btn-next"], [class*="next-btn"], [class*="next_btn"], [class*="btnNext"]';
                let target = null;
                const activeSection = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                // 优先 active section 内的 .btn-next（页面翻页按钮）
                try {
                    if (activeSection) {
                        const list = activeSection.querySelectorAll(sel);
                        for (const el of list) {
                            if (!GraphicAdapter.isUsableNext(el)) continue;
                            if (el.getAttribute && el.getAttribute('data-shuake-nextclicked') === '1') return { clicked: false, reason: 'already-clicked' };
                            target = el; break;
                        }
                    }
                } catch (_) {}
                // 兜底：页面内可见 .btn-next
                if (!target) {
                    try {
                        const list = doc.querySelectorAll(sel);
                        for (const el of list) {
                            if (!GraphicAdapter.isUsableNext(el)) continue;
                            if (el.getAttribute && el.getAttribute('data-shuake-nextclicked') === '1') return { clicked: false, reason: 'already-clicked' };
                            target = el; break;
                        }
                    } catch (_) {}
                }
                if (!target) return { clicked: false, reason: 'no-btn-next' };

                // 站点 btn_timer 节流对齐：真实点击间隔必须 > btn_timer（默认 1200ms）
                const btnTimer = (GraphicAdapter.flipJsCache && GraphicAdapter.flipJsCache.data && GraphicAdapter.flipJsCache.data.btnTimer) || 1200;
                const gap = btnTimer + 200;
                const now = Date.now();
                if (State.lastNextClickTime && now - State.lastNextClickTime < gap) {
                    return { clicked: false, reason: 'throttled' };
                }
                State.lastNextClickTime = now;

                // 调用站点函数：优先页面 jQuery 直接触发（等同调用站点 .btn-next handler 链），
                // 其次 simulateClick 完整 Pointer/Mouse/click 事件序列
                let fired = false;
                try {
                    const pw = _skPw;
                    if (pw && typeof pw.$ === 'function') {
                        const $btn = pw.$(target);
                        if ($btn && typeof $btn.trigger === 'function') {
                            $btn.trigger('click');
                            fired = true;
                        }
                    }
                } catch (_) {}
                if (!fired) {
                    try { DOMUtils.simulateClick(target); fired = true; } catch (_) {}
                }
                if (fired) {
                    try { target.setAttribute('data-shuake-nextclicked', '1'); } catch (_) {}
                    try { Logger.info(`[JS翻页·Tier1] 调用站点 .btn-next 函数: <${target.tagName.toLowerCase()} class="${(target.className || '').substring(0, 50)}">`); } catch (_) {}
                    return { clicked: true, reason: 'js-fn-call' };
                }
                return { clicked: false, reason: 'trigger-failed' };
            } catch (_) {
                return { clicked: false, reason: 'error' };
            }
        }

        // 兜底：直接通过切换 page-active class 翻到下一页（Tier2：加 active class 确定性切页）
        static forceAdvancePage(doc = document, allowStart = false) {
            if (!doc || typeof doc.querySelectorAll !== 'function') return false;
            try {
                let sections = Array.from(doc.querySelectorAll('.page-item'));
                if (sections.length === 0) {
                    try {
                        sections = Array.from(doc.querySelectorAll('[class^="page-"]:not([class*="page-video"]):not([class*="page-wh"]):not([class*="page-container"]):not([class*="page-iframe"])'));
                    } catch (_) {}
                }
                if (sections.length === 0) return false;

                const currentIndex = sections.findIndex(s => s.classList.contains('page-active'));
                if (currentIndex === -1) return false;
                if (currentIndex >= sections.length - 1) return false;

                const nextSection = sections[currentIndex + 1];
                const nextClass = nextSection.className || '';
                if (/page-a[qtf]\d+/.test(nextClass)) {
                    Logger.warning(`下一页是特殊页(${nextClass.trim()})，跳过强制跳转`);
                    return false;
                }

                if (sections[currentIndex].classList.contains('page-start') && !allowStart) {
                    // 诊断：卡在起始页时打印关键状态，定位"开始按钮是否找到 / 是否可点 / 点击状态"
                    try {
                        const actSec = sections[currentIndex];
                        const sb = GraphicAdapter.findStartButton(doc, actSec);
                        const sbInfo = sb ? `${sb.tagName} ${(sb.className || '').substring(0, 40)} vis=${DOMUtils.isVisible(sb)}` : '未找到';
                        Logger.warning(`当前在起始页，等待用户点击开始 [hasClickedStart=${State.hasClickedStart}, startBtn(${sbInfo}), retry=${State.retryCount}]`);
                    } catch (_) {
                        Logger.warning('当前在起始页，等待用户点击开始');
                    }
                    return false;
                }

                sections[currentIndex].classList.remove('page-active');
                nextSection.classList.add('page-active');
                try {
                    // 使用统一入口模拟完整 Pointer/Mouse/click 事件序列
                    DOMUtils.simulateClick(nextSection);
                } catch (_) {}
                Logger.success(`强制翻页: ${currentIndex} -> ${currentIndex + 1} (${nextClass.trim()})`);
                return true;
            } catch (e) {
                Logger.error('强制翻页失败', e);
                return false;
            }
        }

        // 查找下一页按钮
        static findNextButton(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return null;
            try {
                const activeSection = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!activeSection) return null;
                // 本地模糊匹配（自包含：与 GraphicAdapter.fuzzyNextClass 同逻辑，
                // 保证本方法被测试单独抽取 eval 时也能独立运行）
                const fuzzyNext = (value) => {
                    if (!value) return false;
                    const norm = String(value)
                        .replace(/([a-z0-9])([A-Z])/g, '$1·$2')
                        .toLowerCase()
                        .replace(/[-_\s]+/g, '·');
                    return /(?:^|·)btn·?next/.test(norm)
                        || /(?:^|·)next·?btn/.test(norm)
                        || /(?:^|·)page·?next/.test(norm);
                };
                // 编号变体（btn-next26 / btnNext26 / next_btn26）判定，归一化后统一识别
                const isNumNext = (v) => /btn·?next\d|next·?btn\d/.test(
                    String(v || '').replace(/([a-z0-9])([A-Z])/g, '$1·$2').toLowerCase().replace(/[-_\s]+/g, '·'));
                // 跳过已被 [btn-next 兜底] 点击过且未生效的按钮（data-shuake-nextclicked=1），
                // 避免主路径每轮重复点击同一个"死按钮"，导致死循环卡页、永远无法触发跳过
                const isDeadNext = (el) => {
                    try { return !!(el && el.getAttribute && el.getAttribute('data-shuake-nextclicked') === '1'); } catch (_) { return false; }
                };

                // 1. 先在 a/button 中查找
                try {
                    const clickables = activeSection.querySelectorAll('a, button');
                    for (const btn of clickables) {
                        // 可见性：允许 fixed 定位（offsetParent 为 null 但确有渲染盒），仅排除无布局盒元素
                        if (btn.disabled) continue;
                        if (isDeadNext(btn)) continue;
                        try {
                            if (typeof btn.getClientRects === 'function' && btn.getClientRects().length === 0) continue;
                        } catch (_) { continue; }

                        const className = btn.className || '';
                        const href = btn.getAttribute('href') || '';
                        const img = btn.querySelector('img');
                        const src = img ? img.getAttribute('src') || '' : '';

                        if (/prev|back|返回|上/.test(className)) continue;

                        const isNextButton =
                            fuzzyNext(className) ||
                            fuzzyNext(src) ||
                            className.includes('btn-ce') ||
                            className.includes('btn-af') ||
                            className.includes('btn-aq') ||
                            className.includes('btn-at') ||
                            src.includes('btn-ce') ||
                            src.includes('btn-af') ||
                            src.includes('btn-aq') ||
                            src.includes('btn-at') ||
                            src.includes('next') ||
                            (href === 'javascript:;' && className.includes('base-an'));

                        if (isNextButton) {
                            Logger.debug(`找到下一页按钮(a/button): class="${className}", src="${src}"`);
                            return btn;
                        }
                    }
                } catch (e) {}

                // 1.5 兜底：遍历 span / div（如 <span class="page-content-common page-next-btn"></span>）
                try {
                    const allSubs = activeSection.querySelectorAll('span, div');
                    let plainSub = null;   // 优先：纯 btn-next（非编号）
                    let numSub = null;     // 兜底：btn-next26 等编号变体（此类可能为固定叠加层，优先级最低）
                    for (const el of allSubs) {
                        if (!el || el.nodeType !== 1) continue;
                        if (isDeadNext(el)) continue;
                        // 可见性：允许 fixed 定位（offsetParent 为 null 但确有布局盒），只要 getClientRects 有渲染盒即可
                        try {
                            if (typeof el.getClientRects === 'function' && el.getClientRects().length === 0) continue;
                        } catch (_) { continue; }
                        const className = el.className || '';
                        if (/prev|back|返回|上/.test(className)) continue;
                        const txt = (el.textContent || '').trim();
                        if (txt && /prev|back|返回|上/.test(txt)) continue;
                        const isNextCls = fuzzyNext(className);
                        if (!isNextCls) continue;
                        // 编号 btn-next（如 btn-next26）低优先级；纯 btn-next 优先命中
                        if (isNumNext(className)) {
                            if (!numSub) numSub = el;
                        } else {
                            plainSub = el;
                            break;
                        }
                    }
                    const picked = plainSub || numSub;
                    if (picked) {
                        Logger.debug(`找到下一页按钮(span/div): class="${(picked.className || '').substring(0, 40)}"`);
                        return picked;
                    }
                } catch (e) {}

                // 2. 在 page-slide div 中查找 img.btn-next（含模糊变体）
                try {
                    const slideDiv = activeSection.querySelector('.page-slide');
                    if (slideDiv) {
                        let nextImg = null;
                        const slideImgs = slideDiv.querySelectorAll('img');
                        for (const im of slideImgs) {
                            const icls = im.className || '';
                            const isrc = im.getAttribute('src') || '';
                            if (fuzzyNext(icls) || fuzzyNext(isrc)) {
                                nextImg = im;
                                break;
                            }
                        }
                        if (nextImg && !isDeadNext(nextImg) && nextImg.offsetParent !== null) {
                            Logger.debug(`找到下一页按钮(img): ${nextImg.src}`);
                            return nextImg;
                        }
                    }
                } catch (e) {}

                // 3. 在活跃 section 中查找所有 img 元素
                try {
                    const allImgs = activeSection.querySelectorAll('img.element, img.an-position, img[class*="base-an"]');
                    for (const img of allImgs) {
                        if (img.offsetParent === null) continue;
                        if (isDeadNext(img)) continue;
                        const className = img.className || '';
                        const src = img.getAttribute('src') || '';
                        if (fuzzyNext(className)) {
                            Logger.debug(`找到下一页按钮(p0xxx): class="${className}"`);
                            return img;
                        }
                        if (/p\d{4}$/.test(className) && !src.includes('bg') && !src.includes('pend')) {
                            Logger.debug(`找到触发器图片: class="${className}", src="${src}"`);
                            return img;
                        }
                        if (/^p0\d+/.test(src) && /an-position/.test(className)) {
                            Logger.debug(`找到下一页按钮(p0xxx.an-position): src="${src}", class="${className}"`);
                            return img;
                        }
                    }
                } catch (e) {}

                // 4. 兜底：查找 an-position 元素
                try {
                    const anPosImgs = activeSection.querySelectorAll('img.an-position, img[class*="an-position"]');
                    for (const img of anPosImgs) {
                        if (img.offsetParent === null) continue;
                        if (isDeadNext(img)) continue;
                        const src = img.getAttribute('src') || '';
                        if (/btn-start/.test(src) || /bg\d+/.test(src)) continue;
                        if (/^p0\d+\.png$/.test(src)) {
                            Logger.debug(`找到 an-position 翻页按钮: src="${src}"`);
                            return img;
                        }
                    }
                } catch (e) {}

                // 5. 文档级兜底：btn-next 可能是不在 .page-item 内的全局固定层，
                //    此时在整个文档中查找可见的纯 btn-next（排除 btn-next26 等编号叠加层）。
                //    用大小写不敏感选择器 [class*="next" i] 覆盖 btnNext / NEXT 等驼峰变体，
                //    再用 fuzzyNextClass 做归一化校验。
                try {
                    let plainGlobal = null;
                    const globalNexts = doc.querySelectorAll('[class*="next" i]');
                    for (const g of globalNexts) {
                        if (!g || g.nodeType !== 1) continue;
                        if (isDeadNext(g)) continue;
                        const gCls = g.className || '';
                        if (/prev|back|返回|上/.test(gCls)) continue;
                        if (!fuzzyNext(gCls)) continue;
                        // 编号 btn-next（如 btn-next2 / btnNext3 / next_btn4）低优先级，全局兜底不选
                        const gNorm = gCls.toLowerCase().replace(/[-_\s]+/g, '·');
                        if (/btn·?next\d|next·?btn\d/.test(gNorm)) continue;
                        try {
                            if (typeof g.getClientRects === 'function' && g.getClientRects().length === 0) continue;
                        } catch (_) { continue; }
                        plainGlobal = g;
                        break;
                    }
                    if (plainGlobal) {
                        Logger.debug(`找到全局 btn-next(文档级兜底): class="${(plainGlobal.className || '').substring(0, 40)}"`);
                        return plainGlobal;
                    }
                } catch (e) {}
            } catch (e) {
                try { Logger.debug(`findNextButton 异常: ${e.message}`); } catch (_) {}
            }
            return null;
        }

        /**
         * 查找页面上"下一个尚未点击过的可点元素"（逐一点击模式）。
         * 本站部分图文页一个页面有多个可点元素（page-N-contentN / page-boxN-imgN / imgfile / img 触发器），
         * 需要逐一点击后才能解锁下一页。每轮调用返回一个未点击且可见的触发器，用 data-shuake-trigger-clicked 标记去重。
         *
         * 【grid 顺序点击】当页面是 .box.grid 网格布局（grid1~grid4 各含 bgN + contentN）时，
         * 必须按 grid 顺序依次点击：先点完 grid1 的所有可点元素，再 grid2、grid3、grid4……站点才会逐格显示并最终解锁下一页。
         * 每轮调用只返回【当前最早 grid 内】的下一个未点击触发器，避免跨 grid 乱序点击导致站点只响应第一格。
         */
        static findNextTrigger(doc = document, scope = null) {
            const root = scope || doc;
            if (!root || typeof root.querySelectorAll !== 'function') return null;

            // 判定单个元素是否"可点触发器"
            const isTriggerEl = (el) => {
                if (!el || el.nodeType !== 1) return false;
                if (el.getAttribute && el.getAttribute('data-shuake-trigger-clicked') === '1') return false;
                const cls = (el.className || '') + ' ' + (el.tagName === 'IMG' ? (el.getAttribute('src') || '') : '');
                // 排除纯装饰（背景层、页码容器）
                if (/page-\d+-bg\d+/.test(cls) || /\bp\d+bg\b/.test(cls) || /(^|\s)page-next(\s|$)/.test(cls)) return false;
                const isTrigger =
                    /page-\d+-content\d+/.test(cls) ||
                    /page-box\d+-img\d*/.test(cls) ||
                    /page-.*-img\d+/.test(cls) ||
                    /[a-z0-9]*imgfile/.test(cls) ||
                    /p0\d+/.test(cls) ||
                    /(^|\s)box\d{3}(\s|$)/.test(cls) ||
                    el.tagName === 'IMG';
                if (!isTrigger) return false;
                // 可见性：允许 fixed 定位，只要有布局盒即可
                try {
                    if (typeof el.getClientRects === 'function' && el.getClientRects().length === 0) return false;
                } catch (_) { return false; }
                return true;
            };

            // 1) grid 网格布局：按 grid 顺序，先点完当前最早 grid 的所有可点元素
            try {
                const gridContainer = root.querySelector('.box.grid');
                if (gridContainer) {
                    const grids = Array.from(gridContainer.children || []).filter(g => g && g.nodeType === 1);
                    for (let gi = 0; gi < grids.length; gi++) {
                        const g = grids[gi];
                        // 在该 grid 内找下一个未点击的可点元素（含自身与后代）
                        const cands = Array.from(g.querySelectorAll('span, div, img'));
                        if (g.matches && g.matches('span, div, img')) cands.unshift(g);
                        for (const c of cands) {
                            if (!isTriggerEl(c)) continue;
                            // 只返回当前最早 grid 内的元素，保证 grid 顺序
                            return c;
                        }
                        // 当前 grid 已无可点元素，继续下一个 grid
                    }
                    // 所有 grid 都点完了：不要 return null——继续往下走全局 DOM 顺序查找，
                    // 覆盖 grid 外的其他触发器（如 .boxbg 容器内的 box101~box406）
                }
            } catch (_) {}

            // 2) 非 grid 布局：按 DOM 顺序查找下一个未点击触发器
            let els = [];
            try {
                els = Array.from(root.querySelectorAll(
                    '.page-slide span, .page-slide div, .page-slide img, ' +
                    'span[class*="content"], span[class*="imgfile"], ' +
                    'img.element, img.an-position, img[class*="base-an"], img[class*="p0"]'
                ));
            } catch (_) { els = []; }
            for (const el of els) {
                if (isTriggerEl(el)) return el;
            }
            return null;
        }

        /**
         * 检测页内是否存在"尚未显示/尚未点完"的 boxbg 容器。
         * 本站 grid 页交互：grid 全部点完后，boxbg box1 才从 display:none 变为 block 显示，
         * 点完 box1 内所有可点元素后 box2 显示……依此类推。
         * 只要还有 display:none（未显示）的 boxbg，说明页面尚未点完，不应强制翻页。
         */
        static hasPendingBox(doc = document, scope = null) {
            const root = scope || doc;
            if (!root || typeof root.querySelectorAll !== 'function') return false;
            try {
                const boxes = Array.from(root.querySelectorAll('.boxbg'));
                if (boxes.length === 0) return false;
                for (const b of boxes) {
                    // 有 display:none 的 boxbg → 还有未显示的 box
                    const cs = b && b.style ? b.style.display : '';
                    if (cs === 'none') return true;
                    // 无内联 display 时按 getClientRects 判断不可见
                    if (typeof b.getClientRects === 'function') {
                        try { if (b.getClientRects().length === 0) return true; } catch (_) {}
                    }
                }
                // 所有 boxbg 都已显示：再检查是否有【可见】box 内元素未被点击
                // （display:none 的元素不算未点完，如 box 内被站点隐藏重排的 page-boxN-imgN）
                for (const b of boxes) {
                    const inner = Array.from(b.querySelectorAll('span, div, img'));
                    for (const el of inner) {
                        if (!el || el.nodeType !== 1) continue;
                        if (el.getAttribute && el.getAttribute('data-shuake-trigger-clicked') === '1') continue;
                        try {
                            if (typeof el.getClientRects === 'function' && el.getClientRects().length === 0) continue;
                        } catch (_) { continue; }
                        return true;
                    }
                }
            } catch (_) {}
            return false;
        }

        /**
         * grid 页状态机：本站 grid 页交互是【grid → box → grid → box…严格依次】：
         *   1. 点击 gridN.contentN → 站点显示 boxbg boxN
         *   2. 依次点击 boxN 内所有可点元素（boxN01~boxN06、page-boxN-imgN）
         *   3. boxN 全部点完 → 点击 grid(N+1).contentN+1 → box(N+1) 显示 → 重复
         * 若 content 点得太早（前一个 box 未完成时点的不被站点接受，box 不会显示），
         * 当前一个 box 完成后需要【重新点击】该 content 来触发对应 box 显示。
         * 返回 { action, el }：
         *   clickContent  → 点击 content（前置 box 已完成）
         *   reclickContent→ 重新点击 content（content 已标记但 box 未显示，前置 box 已完成）
         *   clickBox      → 点击 box 内下一个未点击的可点元素
         *   wait          → 前置 box 尚未完成，等待
         *   done          → 所有 grid+box 处理完毕
         *   null          → 非 grid 页
         */
        static findNextGridAction(doc = document, scope = null) {
            const root = scope || doc;
            if (!root || typeof root.querySelectorAll !== 'function') return null;
            try {
                const gridContainer = root.querySelector('.box.grid');
                if (!gridContainer) return null;
                const grids = Array.from(gridContainer.children || []).filter(g => g && g.nodeType === 1);
                const boxes = Array.from(root.querySelectorAll('.boxbg'));
                if (grids.length === 0) return null;

                const isVisibleEl = (el) => {
                    if (!el || el.nodeType !== 1) return false;
                    try { return typeof el.getClientRects === 'function' && el.getClientRects().length > 0; } catch (_) { return false; }
                };
                const marked = (el) => !!(el && el.getAttribute && el.getAttribute('data-shuake-trigger-clicked') === '1');
                const isClickable = (el) => {
                    if (!el || el.nodeType !== 1) return false;
                    const cls = (el.className || '') + ' ';
                    if (/page-\d+-bg\d+/.test(cls) || /\bp\d+bg\b/.test(cls)) return false;
                    return /page-\d+-content\d+/.test(cls) ||
                        /page-box\d+-img\d*/.test(cls) ||
                        /page-.*-img\d+/.test(cls) ||
                        /[a-z0-9]*imgfile/.test(cls) ||
                        /(^|\s)box\d{3}(\s|$)/.test(cls) ||
                        el.tagName === 'IMG';
                };
                // box 内"可见且可点"的元素（display:none 的不算）
                const boxClickables = (pb) => Array.from((pb ? pb.querySelectorAll('span, div, img') : [])).filter(el => isClickable(el) && isVisibleEl(el));
                const boxDone = (pb) => {
                    if (!pb) return true;
                    // 强完成信号：box 内"box 专用元素"（box101 等 box\d{3}）已全部标记。
                    // 站点在 box 点完后会隐藏该 box（display:block→none）并显示下一个，
                    // 此时不能靠可见性判断（隐藏=未完成是错的），只认内部元素是否全部点过。
                    const inner = Array.from(pb.querySelectorAll('span, div, img'));
                    const boxEls = inner.filter(el => isClickable(el) && /(^|\s)box\d{3}(\s|$)/.test((el.className || '') + ' '));
                    if (boxEls.length > 0) {
                        return boxEls.every(el => marked(el));
                    }
                    // 无 box 专用元素（如只有 page-boxN-img*）：box 未显示时其元素不可见，
                    // 不能用可见性判断，须看"所有可点元素是否全部标记"（隐藏未处理 → 未完成）
                    const allClickables = inner.filter(el => isClickable(el));
                    return allClickables.length === 0 || allClickables.every(el => marked(el));
                };

                // 取 grid 的 content 元素
                const getContent = (g) => {
                    if (!g) return null;
                    const gCands = Array.from(g.querySelectorAll('span, div'));
                    if (g.matches && g.matches('span, div')) gCands.unshift(g);
                    for (const c of gCands) {
                        if (!isClickable(c)) continue;
                        if (/content\d+/.test(c.className || '')) return c;
                    }
                    return null;
                };

                // ===== 阶段 A：所有 grid 都要点按钮 =====
                // 依次点击尚未点击过的 content（grid1→grid2→grid3→grid4），
                // 不因某个 box 未显示而阻塞，保证"所有 grid 按钮都被点到"
                for (let gi = 0; gi < grids.length; gi++) {
                    const contentEl = getContent(grids[gi]);
                    if (contentEl && !marked(contentEl)) {
                        return { action: 'clickContent', el: contentEl };
                    }
                }

                // ===== 阶段 B：所有 content 已点，处理 box =====
                // 页面级可点元素（.page-slide 内、grid/box 之外，如 page-26-img1/2）——
                // 站点可能用它们作为"box1 完成 → 显示 box2"的推进触发器
                const pageLevelTriggers = () => {
                    try {
                        const slide = root.querySelector('.page-slide');
                        if (!slide) return [];
                        const out = [];
                        for (const el of Array.from(slide.querySelectorAll('span, div, img'))) {
                            if (!el || el.nodeType !== 1) continue;
                            if (el.closest && (el.closest('.box.grid') || el.closest('.boxbg'))) continue;
                            if (!isClickable(el) || !isVisibleEl(el)) continue;
                            out.push(el);
                        }
                        return out;
                    } catch (_) { return []; }
                };
                for (let gi = 0; gi < grids.length; gi++) {
                    const boxEl = boxes[gi] || null;
                    const prevBoxDone = gi === 0 ? true : boxDone(boxes[gi - 1]);
                    if (!boxEl) continue;
                    // box 已完成（内部可点元素全部点过，即使被站点隐藏）→ 跳过，不 reclick
                    if (boxDone(boxEl)) continue;
                    if (isVisibleEl(boxEl)) {
                        // box 已显示：点未点击的 box 内元素
                        const unmarked = boxClickables(boxEl).filter(el => !marked(el));
                        if (unmarked.length > 0) return { action: 'clickBox', el: unmarked[0] };
                        // box 已全部点完 → 继续下一个 grid
                        continue;
                    }
                    // box 未显示：
                    // 1) 交接态（gi>0 且前置 box 完成）：站点可能显示页面级触发器（如 page-26-img1）作为推进按钮
                    if (gi > 0 && prevBoxDone) {
                        const pageEls = pageLevelTriggers().filter(el => !marked(el));
                        if (pageEls.length > 0) {
                            return { action: 'clickPage', el: pageEls[0] };
                        }
                    }
                    // 2) 重试 content 触发 box 显示
                    if (prevBoxDone) {
                        const contentEl = getContent(grids[gi]);
                        if (contentEl) return { action: 'reclickContent', el: contentEl };
                    }
                    // 3) 等待
                    return { action: 'wait', el: null };
                }
                // 所有 grid+box 处理完：返回 done，主流程去翻页（含页面级剩余触发器）
                return { action: 'done', el: null };
            } catch (_) { return null; }
        }

        // 检测并处理问答选择（单选循环枚举）
        static handleQuizSelection(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                let activeSection = doc.querySelector('.page-item.page-active');
                if (!activeSection) activeSection = doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!activeSection) return false;
                const actCls = activeSection.className || '';

                // ======== Tier -0.5：课中观点题（page-19 投票题，name="ai19"）========
                // 无对错、投票显示百分比。处理：勾选首个可用选项 → 触发 label（站点显示 .btn-aq-19）
                // → 点击 .btn-aq-19 提交（站点 saveQuestions 出百分比 + 显示 .btn-next）。
                // 已提交（选项 disabled）→ isQuizPage 已放行翻页，这里直接返回 false 不重复处理。
                try {
                    if (activeSection.querySelector('input[name="ai19"]')) {
                        const _allV = activeSection.querySelectorAll('input[name="ai19"]');
                        const _vDone = Array.from(_allV).some(function (i) { return i.disabled; });
                        if (_vDone) return false;
                        let _picked = false;
                        for (let _vi = 0; _vi < _allV.length; _vi++) {
                            if (!_allV[_vi].disabled) {
                                try { _allV[_vi].checked = true; } catch (_) {}
                                _picked = true;
                                break;
                            }
                        }
                        try {
                            const _lbl = _allV[0] && _allV[0].closest && _allV[0].closest('label');
                            if (_lbl) {
                                try { _lbl.click(); } catch (_) {}
                                try { _lbl.dispatchEvent(new Event('click', { bubbles: true })); } catch (_) {}
                            }
                        } catch (_) {}
                        const _vBtn = activeSection.querySelector('.btn-aq-19, [class*="btn-aq-19"]');
                        if (_vBtn) {
                            try { if (typeof DOMUtils !== 'undefined' && DOMUtils.simulateClick) DOMUtils.simulateClick(_vBtn); } catch (_) {}
                            try { if (_vBtn.click) _vBtn.click(); } catch (_) {}
                        }
                        try { Logger.info('[观点题] 已选首个选项并点击 btn-aq-19 提交投票'); } catch (_) {}
                        return true;
                    }
                } catch (_) {}

                // ======== Tier 0.5：新版编号页模板 btn-aq-n / btn-aq-y 结构 ========
                // 用户 JS：
                //   $(".btn-aq-n").each(...)  -> $(this).parents("section").prop("id") + 1 → .page-N+1
                //   $(".btn-aq-y").each(...)  -> $(this).parents("section").prop("id") + 2 → .page-N+2
                // 这种模板的答题页是 <section id="N"> 内两个按钮（是/否 或 正确/继续），无 label+radio 选项。
                // 有 radio/checkbox 选项时交给下方选项旋转/题库路径；纯按钮时按"是/继续"（btn-aq-y）推进。
                try {
                    if (activeSection.querySelector && (activeSection.querySelector('.btn-aq-y, [class*="btn-aq-y"]') || activeSection.querySelector('.btn-aq-n, [class*="btn-aq-n"]'))) {
                        const hasOptionInput = !!activeSection.querySelector('input[type="radio"], input[type="checkbox"]');
                        if (!hasOptionInput && typeof GraphicJsAdapter !== 'undefined' && GraphicJsAdapter && typeof GraphicJsAdapter.advanceAqYes === 'function') {
                            const useYes = !!activeSection.querySelector('.btn-aq-y, [class*="btn-aq-y"]');
                            const r = useYes ? GraphicJsAdapter.advanceAqYes(doc) : GraphicJsAdapter.advanceAqNo(doc);
                            if (r && r.ok) {
                                try { Logger.info(`[JS 答题] btn-aq-${useYes ? 'y' : 'n'} 推进成功: ${r.reason}, from=${r.from} to=${r.to}`); } catch (_) {}
                                return true;
                            }
                        }
                    }
                } catch (_) {}

                // ======== Tier 0：JS 优先（新版 item.js 答题链） ==========
                //   · page-atNN：答对页 → jQuery .btn-at trigger 跳下一题 / 跳出答题
                //   · page-afNN：答错页 → jQuery .btn-af trigger 回 .page-aqNN 重试
                //   · page-aqNN + 命中题库：GraphicJsAdapter.solveQuizSubmit 直接触发对应 label（slFn handler 自动判对/错并播音效）
                if (typeof GraphicJsAdapter !== 'undefined' && GraphicJsAdapter && GraphicJsAdapter.hasNativeSupport && GraphicJsAdapter.hasNativeSupport()) {
                    // 0a) 答对页：.page-atNN → advanceAtPage
                    if (/page-at\d+/.test(actCls)) {
                        // 答对进入下一题 → 重置尝试计数（下一题从头轮换选项）
                        State.quizAttempts = 0;
                        const r = GraphicJsAdapter.advanceAtPage(doc);
                        if (r && r.ok) {
                            try { Logger.info(`[JS 答题] 答对页推进成功: ${r.reason}, cls=${actCls}`); } catch (_) {}
                            return true;
                        }
                    }
                    // 0b) 答错页：.page-afNN → advanceAfPage
                    if (/page-af\d+/.test(actCls)) {
                        // 答错返回前递增尝试计数：使下轮在答题页轮换选项
                        // （quizAttempts % 选项数 → A 错 → B → C...），实现"递归逐一测试"，
                        // 而不是永远重试第一个选项（日志特征：尝试 #1 恒定不变）。
                        State.quizAttempts++;
                        if (State.quizAttempts >= (State.maxQuizAttempts || 6)) {
                            // 已达上限：放弃该题（跳过），避免无答案/题库错误导致死循环
                            try { Logger.warning(`问答尝试达上限 (${State.quizAttempts})，跳过该题`); } catch (_) {}
                            State.quizCompleted = true;
                            const skipNext = GraphicJsAdapter.advanceAfPage(doc);
                            if (skipNext && skipNext.ok) {
                                try { Logger.info(`[JS 答题] 答错达上限，跳过返回: ${skipNext.reason}`); } catch (_) {}
                            } else {
                                try { GraphicAdapter.forceAdvancePage(doc); } catch (_) {}
                            }
                            return true;
                        }
                        const r = GraphicJsAdapter.advanceAfPage(doc);
                        if (r && r.ok) {
                            try { Logger.info(`[JS 答题] 答错返回成功: ${r.reason}, cls=${actCls} (尝试 #${State.quizAttempts})`); } catch (_) {}
                            return true;
                        }
                    }
                    // 0c) 答题页：.page-aqNN + 本地题库/AI 命中 → solveQuizSubmit 走 slFn label click
                    if (/page-aq\d+/.test(actCls)) {
                        try {
                            const allInputs = activeSection.querySelectorAll('input[type="radio"], input[type="checkbox"]');
                            if (allInputs && allInputs.length) {
                                const fst = allInputs[0];
                                const radioName = fst.getAttribute('name') || '';   // ai01/ai02/ai03/ai04
                                const letters = Array.from(allInputs).map(i => String(i.value || '').toUpperCase()).filter(Boolean);
                                if (radioName && letters.length) {
                                    // 构造题干 + 选项文本 → 本地题库 / AI 缓存
                                    let q = '';
                                    let optTexts = [];
                                    try {
                                        const dtxEl = activeSection.querySelector('.dtx, .pagedtx, [class*="dtx"]');
                                        q = ((dtxEl && dtxEl.textContent) || activeSection.textContent || '').replace(/\s+/g, ' ').trim();
                                        if (q.length > 200) q = q.substring(0, 200);
                                        optTexts = Array.from(allInputs).map(i => {
                                            const l = i.closest('label');
                                            return (l ? l.textContent : i.value || '').trim();
                                        });
                                    } catch (_) {}
                                    // 【接口答案优先】mercuryprovider/listQuestion 的 isCorrect 精确答案（option.id 与 DOM input.value 对应）：
                                    // 未加载则懒加载并等待（不猜题，避免答错跳到结束页触发风控）
                                    try {
                                        const _tried = !!(State && State._quizAnswersTried);
                                        const _loading = !!(State && State._quizAnswersLoading);
                                        if (typeof State === 'undefined' || !State._quizAnswerMap) {
                                            if (!_tried) {
                                                // 接口答案未尝试/加载中：等待（不猜题避免答错触发风控）
                                                if (!_loading) { GraphicJsAdapter.fetchQuizAnswers(''); }
                                                return 'waiting';
                                            }
                                            // 接口答案获取失败（tried）：回退下方本地题库/猜题，绝不能无限等待卡死答题页
                                        } else {
                                            const _qIdx = parseInt((radioName.match(/(\d+)/) || [])[1] || '-1', 10);
                                            const _amap = State._quizAnswerMap;
                                            if (_amap && _amap[_qIdx] && _amap[_qIdx].correctIds && _amap[_qIdx].correctIds.length) {
                                                const _qNum = (actCls.match(/page-aq0*(\d+)/) || [])[1] || '';
                                                const _cp = _qNum ? `.page-at${String(+_qNum).padStart(2, '0')}` : '';
                                                const _wp = _qNum ? `.page-af${String(+_qNum).padStart(2, '0')}` : '';
                                                const _r = GraphicJsAdapter.solveQuizSubmitOptions(doc, radioName, _amap[_qIdx].correctIds, _cp, _wp);
                                                if (_r && _r.ok) {
                                                    try { Logger.info(`[JS 答题] 接口答案提交: ${_r.reason}, radio=${radioName}, 正确选项=${_amap[_qIdx].correctIds.length}`); } catch (_) {}
                                                    return true;
                                                }
                                            }
                                        }
                                    } catch (_) {}
                                    let correctLetter = null;
                                    if (typeof AIAnswer !== 'undefined' && AIAnswer) {
                                        try {
                                            if (AIAnswer.getLocalAnswer) {
                                                const rec = AIAnswer.getLocalAnswer(q, optTexts);
                                                if (rec && rec.answer) correctLetter = String(rec.answer).toUpperCase();
                                            }
                                            if (!correctLetter && AIAnswer.generateQuestionHash && State.aiAnswerCache) {
                                                const h = AIAnswer.generateQuestionHash(q, optTexts);
                                                if (State.aiAnswerCache.has(h)) correctLetter = String(State.aiAnswerCache.get(h) || '').toUpperCase();
                                            }
                                        } catch (_) {}
                                    }
                                    // 【递归逐一测试】题库/AI 答案只在首次尝试（quizAttempts===0）使用；
                                    // 一旦答错过（quizAttempts>0），题库答案可能本身错误，
                                    // 不再重复提交同一答案，交给下方选项轮换逐一测试。
                                    if (correctLetter && (State.quizAttempts || 0) === 0) {
                                        const firstLetter = correctLetter.split(/[,，\s]+/)[0]; // 单选取第一个
                                        // 推断答题成功 / 失败页选择器：新版 slFn 参数为 at = .page-atNN / af = .page-afNN
                                        const qNum = (actCls.match(/page-aq0*(\d+)/) || [])[1] || '';
                                        const correctPageSel = qNum ? `.page-at${String(+qNum).padStart(2, '0')}` : '';
                                        const wrongPageSel = qNum ? `.page-af${String(+qNum).padStart(2, '0')}` : '';
                                        const r = GraphicJsAdapter.solveQuizSubmit(doc, radioName, firstLetter, correctPageSel, wrongPageSel);
                                        if (r && r.ok) {
                                            try { Logger.info(`[JS 答题] solveQuizSubmit: ${r.reason}, radio=${radioName}, answer=${firstLetter}`); } catch (_) {}
                                            return true;
                                        }
                                    }
                                }
                            }
                        } catch (_) {}
                    }
                }
                // ================ Tier 1+：原有 DOM 模拟路径 ================

                let quizContainer = activeSection.querySelector('.dtx, .aq-item, .quiz-options, .pagedtx, [class*="dtx"]');
                if (!quizContainer) {
                    // 新版图文模板（slFn 结构，page-aqNN 内 label 包 radio，无 .dtx/.quiz-options 容器）：
                    // 把整个 page-aqNN 作为兜底容器，使单选/多选旋转答题仍能执行。
                    const hasQuizInput = !!activeSection.querySelector('input[type="radio"], input[type="checkbox"]');
                    const hasQuizLabel = !!activeSection.querySelector('label');
                    if (hasQuizInput || hasQuizLabel) {
                        quizContainer = activeSection;
                    } else {
                        return false;
                    }
                }

                Logger.debug(`quizContainer: ${quizContainer.className}, inputs: ${quizContainer.querySelectorAll('input').length}, labels: ${quizContainer.querySelectorAll('label').length}`);

                const allInputs = quizContainer.querySelectorAll('input[type="checkbox"], input[type="radio"]');
                if (allInputs.length === 0) {
                    const labels = quizContainer.querySelectorAll('label.aq-item-label, label[class*="aq-item"]');
                    Logger.debug(`无 input，找 label: ${labels.length} 个`);
                    if (labels.length > 0) {
                        return this.selectQuizOptionByLabel(labels, activeSection);
                    }
                    return false;
                }

                // 检查是否需要重试（返回按钮存在）
                const backBtn = this.findQuizBackButton(doc);
                if (backBtn && backBtn.offsetParent !== null) {
                    try { DOMUtils.simulateClick(backBtn); } catch (e) {}
                    State.quizAttempts++;
                    Logger.warning(`问答答案错误，第 ${State.quizAttempts} 次重试`);

                    if (State.quizAttempts >= State.maxQuizAttempts) {
                        Logger.error(`问答重试次数已达上限 (${State.maxQuizAttempts})，跳过`);
                        State.quizCompleted = true;
                        return false;
                    }

                    setTimeout(() => {
                        State.quizCompleted = false;
                    }, 500);
                    return true;
                }

                // 已经有选项被选中
                const anyChecked = Array.from(allInputs).some(input => input.checked);
                if (anyChecked) {
                    // 与下方主确认选择器保持一致：支持 <img class="...btn-at-NN"> 模板
                    const confirmBtn = activeSection.querySelector('.btn-aq-item, .btn-at, [class*="btn-at"], button[class*="aq"], a[class*="aq"]');
                    if (confirmBtn && confirmBtn.offsetParent !== null) {
                        try { DOMUtils.simulateClick(confirmBtn); } catch (e) {}
                        Logger.debug('点击问答确认按钮');
                    }
                    return true;
                }

                // 提取题干文本用于查题库
                let questionText = '';
                let optionTexts = [];
                try {
                    const dtxEl = activeSection.querySelector('.dtx, .pagedtx, [class*="dtx"]');
                    questionText = ((dtxEl && dtxEl.textContent) || activeSection.textContent || '').replace(/\s+/g, ' ').trim();
                    if (questionText.length > 200) questionText = questionText.substring(0, 200);
                    optionTexts = inputsArray.map(inp => {
                        const lab = inp.closest('label');
                        return (lab ? lab.textContent : inp.value || '').trim();
                    });
                } catch (_) {}

                // 选择一个选项
                const inputsArray = Array.from(allInputs);
                // 真实判断：所有 input.type 是否为 radio（单选）/ checkbox（多选/判断）
                const allRadio = inputsArray.every(input => input.type === 'radio');
                const anyCheckbox = inputsArray.some(input => input.type === 'checkbox');
                const isMultiChoice = anyCheckbox; // checkbox 视为多选
                const isSingleChoice = allRadio && !anyCheckbox; // radio 视为单选

                // 构造本次应选的索引集合
                let pickedIndexes = [];

                // 优先尝试：从本地题库 / AI 缓存命中
                let usedBankAnswer = null;
                if (typeof AIAnswer !== 'undefined' && AIAnswer && AIAnswer.getLocalAnswer) {
                    try {
                        const rec = AIAnswer.getLocalAnswer(questionText, optionTexts);
                        if (rec && rec.answer) {
                            usedBankAnswer = String(rec.answer);
                            Logger.info(`命中本地题库（问答）: ${usedBankAnswer}`);
                        }
                    } catch (_) {}
                }
                if (!usedBankAnswer && typeof AIAnswer !== 'undefined' && AIAnswer && AIAnswer.generateQuestionHash) {
                    try {
                        const qHash = AIAnswer.generateQuestionHash(questionText, optionTexts);
                        if (State.aiAnswerCache && State.aiAnswerCache.has(qHash)) {
                            usedBankAnswer = String(State.aiAnswerCache.get(qHash) || '');
                            Logger.info(`命中 AI 缓存（问答）: ${usedBankAnswer}`);
                        }
                    } catch (_) {}
                }
                // 【试卷预解析】全卷预解析答案命中（startPaper.do 预取时已用本地题库/缓存解析）
                if (!usedBankAnswer && typeof AIAnswer !== 'undefined' && AIAnswer && AIAnswer.generateQuestionHash) {
                    try {
                        const qHash2 = AIAnswer.generateQuestionHash(questionText, optionTexts);
                        if (qHash2 && typeof ExamPaper !== 'undefined') {
                            const pre = ExamPaper.getPreAnswer(qHash2);
                            if (pre) {
                                usedBankAnswer = String(pre);
                                try { if (State.aiAnswerCache) State.aiAnswerCache.set(qHash2, usedBankAnswer); } catch (_) {}
                                try { Logger.info(`命中全卷预解析答案: ${usedBankAnswer}`); } catch (_) {}
                            }
                        }
                    } catch (_) {}
                }

                if (usedBankAnswer) {
                    // 题库答案格式：'A' / 'B,C' / 'AB' 等 → 解析成索引
                    const letters = usedBankAnswer.toUpperCase().split(/[,，\s]+/).filter(Boolean);
                    // 优先按 value 字母匹配
                    for (const letter of letters) {
                        const idx = inputsArray.findIndex(inp => String(inp.value || '').toUpperCase() === letter);
                        if (idx !== -1) pickedIndexes.push(idx);
                    }
                    // 题库答错回退路径：将 pickedIndexes 留空走轮换
                    if (pickedIndexes.length === 0) {
                        // 解析失败，则不采纳题库答案，走随机轮换
                        usedBankAnswer = null;
                    }
                }

                if (pickedIndexes.length === 0) {
                    if (isSingleChoice) {
                        // 单选：根据 quizAttempts 轮换
                        pickedIndexes = [State.quizAttempts % inputsArray.length];
                    } else if (isMultiChoice) {
                        // 多选策略：
                        //   优先"全选"，答错后再循环枚举所有非空子集（递归枚举）
                        const totalSubsets = (1 << inputsArray.length) - 1; // 2^n - 1
                        // 排列顺序：先全选(0b111...)，再按子集大小 → 子集二进制升序
                        const attempt = State.quizAttempts || 0;
                        if (attempt === 0) {
                            // 第1次：全选
                            pickedIndexes = inputsArray.map((_, i) => i);
                        } else {
                            // 后续：递归枚举所有非空子集，跳过全选
                            // 生成顺序：从大到小、再按二进制升序
                            const subsets = [];
                            for (let mask = 1; mask <= (1 << inputsArray.length) - 1; mask++) {
                                const indexes = [];
                                for (let i = 0; i < inputsArray.length; i++) {
                                    if (mask & (1 << i)) indexes.push(i);
                                }
                                subsets.push(indexes);
                            }
                            // 先按子集大小降序（选项越多越优先），再按 mask 升序
                            subsets.sort((a, b) => {
                                if (b.length !== a.length) return b.length - a.length;
                                // mask 数值小的排前面
                                const ma = a.reduce((acc, i) => acc | (1 << i), 0);
                                const mb = b.reduce((acc, i) => acc | (1 << i), 0);
                                return ma - mb;
                            });
                            // 第1次是全选(attempt=0)，所以枚举索引从 0 开始（含全选）
                            const idx = attempt % subsets.length;
                            pickedIndexes = subsets[idx] || [0];
                        }
                        Logger.debug(`多选共 ${totalSubsets} 种可能，本次选择: [${pickedIndexes.join(',')}] (#${attempt + 1})`);
                    } else {
                        pickedIndexes = [State.quizAttempts % inputsArray.length];
                    }
                }

                // 执行选择
                for (const idx of pickedIndexes) {
                    const input = inputsArray[idx];
                    if (!input) continue;
                    const label = input.closest('label');
                    if (label && (input.offsetParent === null || input.type === 'hidden')) {
                        try { DOMUtils.simulateClick(label); } catch (e) {}
                    } else {
                        try {
                            input.checked = true;
                            input.dispatchEvent(new Event('change', { bubbles: true }));
                        } catch (e) {}
                    }
                }
                Logger.debug(`问答选择: ${isMultiChoice ? '多选' : '单选'} 选项 [${pickedIndexes.map(i => inputsArray[i]?.value || (i + 1)).join(',')}] (尝试 #${State.quizAttempts + 1})`);

                // 【多选 checkbox 模板兼容】确认按钮可能是 <img class="... btn-at-01 / btn-at-02 ...">：
                // 站点 Btnat(".btn-at-01", ".page-1", [答案]) 的按钮类名是 btn-at-NN（带序号），
                // 原选择器 .btn-at（精确 token）匹配不到，必须用 [class*="btn-at"] 模糊匹配。
                // 该模板点击后只要选中项非空即推进下一页（正确性仅 console 提示），故勾选+点击即完成。
                const confirmBtn2 = activeSection.querySelector('.btn-aq-item, .btn-at, [class*="btn-at"], button[class*="aq"], a[class*="aq"]');
                if (confirmBtn2 && confirmBtn2.offsetParent !== null) {
                    try { DOMUtils.simulateClick(confirmBtn2); } catch (e) {}
                    Logger.debug('点击问答确认按钮');
                }
                return true;
            } catch (e) {
                try { Logger.debug(`handleQuizSelection 异常: ${e.message}`); } catch (_) {}
                return false;
            }
        }

        // 通过 label 点击来处理问答选择
        static selectQuizOptionByLabel(labels, activeSection) {
            if (!labels || labels.length === 0) return false;
            if (!activeSection) return false;
            try {
                // 判断 label 内的 input 是否有 checkbox（多选）
                const sampleInput = labels[0].querySelector('input[type="checkbox"], input[type="radio"]');
                const isMultiChoice = !!(sampleInput && sampleInput.type === 'checkbox');

                // 提取题干 + 选项文本用于查题库
                let questionText = '';
                let optionTexts = [];
                try {
                    const dtxEl = activeSection.querySelector('.dtx, .pagedtx, [class*="dtx"]');
                    questionText = ((dtxEl && dtxEl.textContent) || activeSection.textContent || '').replace(/\s+/g, ' ').trim();
                    if (questionText.length > 200) questionText = questionText.substring(0, 200);
                    optionTexts = Array.from(labels).map(l => (l.textContent || '').trim());
                } catch (_) {}

                let pickedIndexes = [];
                // 题库命中优先
                if (typeof AIAnswer !== 'undefined' && AIAnswer && AIAnswer.getLocalAnswer) {
                    try {
                        const rec = AIAnswer.getLocalAnswer(questionText, optionTexts);
                        if (rec && rec.answer) {
                            const letters = String(rec.answer).toUpperCase().split(/[,，\s]+/).filter(Boolean);
                            for (const letter of letters) {
                                const idx = Array.from(labels).findIndex(l => {
                                    const txt = (l.textContent || '').trim().toUpperCase();
                                    return txt.startsWith(letter);
                                });
                                if (idx !== -1) pickedIndexes.push(idx);
                            }
                            if (pickedIndexes.length > 0) {
                                Logger.info(`命中本地题库（label）: ${rec.answer}`);
                            } else {
                                pickedIndexes = [];
                            }
                        }
                    } catch (_) {}
                }

                if (pickedIndexes.length === 0) {
                    if (isMultiChoice) {
                        // 多选策略：全选优先 → 递归枚举所有非空子集
                        const totalSubsets = (1 << labels.length) - 1;
                        const attempt = State.quizAttempts || 0;
                        if (attempt === 0) {
                            pickedIndexes = labels.map((_, i) => i);
                        } else {
                            const subsets = [];
                            for (let mask = 1; mask <= (1 << labels.length) - 1; mask++) {
                                const indexes = [];
                                for (let i = 0; i < labels.length; i++) {
                                    if (mask & (1 << i)) indexes.push(i);
                                }
                                subsets.push(indexes);
                            }
                            subsets.sort((a, b) => {
                                if (b.length !== a.length) return b.length - a.length;
                                const ma = a.reduce((acc, i) => acc | (1 << i), 0);
                                const mb = b.reduce((acc, i) => acc | (1 << i), 0);
                                return ma - mb;
                            });
                            const idx = attempt % subsets.length;
                            pickedIndexes = subsets[idx] || [0];
                        }
                        Logger.debug(`多选共 ${totalSubsets} 种可能，本次选择: [${pickedIndexes.join(',')}] (#${attempt + 1})`);
                    } else {
                        pickedIndexes = [State.quizAttempts % labels.length];
                    }
                }

                for (const idx of pickedIndexes) {
                    try { DOMUtils.simulateClick(labels[idx]); } catch (e) {}
                }
                Logger.debug(`点击问答选项: [${pickedIndexes.map(i => i + 1).join(',')}]/${labels.length} (#${State.quizAttempts + 1}, ${isMultiChoice ? '多选' : '单选'})`);

                setTimeout(() => {
                    try {
                        const confirmBtn = activeSection.querySelector('.btn-aq-item, .btn-at, button[class*="aq"], a[class*="aq"]');
                        if (confirmBtn && confirmBtn.offsetParent !== null) {
                            DOMUtils.simulateClick(confirmBtn);
                            Logger.debug('点击问答确认按钮');
                        }
                    } catch (e) {}
                }, 300);
            } catch (e) {
                try { Logger.debug(`selectQuizOptionByLabel 异常: ${e.message}`); } catch (_) {}
            }
            return true;
        }

        // 检测问答答案是否错误
        static isQuizError(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                const activeSection = doc.querySelector('.page-item.page-active');
                if (!activeSection) return false;

                const hasQuizContent = activeSection.querySelector('.dtx, .aq-item, input[type="radio"], input[type="checkbox"]');
                if (!hasQuizContent) return false;

                const backBtn = this.findQuizBackButton(doc);
                if (backBtn && backBtn.offsetParent !== null) {
                    return true;
                }

                const errorIndicators = [
                    '.aq-error', '.quiz-error', '.error-tip',
                    '[class*="aq-error"]', '[class*="wrong"]'
                ];
                for (const sel of errorIndicators) {
                    if (activeSection.querySelector(sel)) {
                        return true;
                    }
                }
            } catch (e) {}
            return false;
        }

        // 查找返回按钮
        static findQuizBackButton(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return null;
            try {
                const selectors = [
                    '.btn-aq-item.btn-af',
                    'a.btn-af',
                    '.btn-af',
                    'a[class*="af"]',
                    '[class*="btn-aq-item"][class*="af"]',
                    'img[src*="btn-af"]'
                ];
                for (const sel of selectors) {
                    const btn = doc.querySelector(sel);
                    if (btn && btn.offsetParent !== null) {
                        return btn.closest('a') || btn;
                    }
                }

                const allBtns = doc.querySelectorAll('a[href="javascript:;"]');
                for (const btn of allBtns) {
                    const text = (btn.textContent || '').toLowerCase();
                    if (text.includes('返回') || text.includes('重试') || text.includes('再来')) {
                        return btn;
                    }
                }
            } catch (e) {}
            return null;
        }

        // 处理问答错误并返回重试
        static handleQuizError(doc = document) {
            try {
                const backBtn = this.findQuizBackButton(doc);
                if (backBtn) {
                    State.quizAttempts++;
                    State.quizErrorRetry = true;
                    Logger.warning(`问答答案错误，第 ${State.quizAttempts} 次重试`);
                    try { DOMUtils.simulateClick(backBtn); } catch (e) {}
                    State.quizCompleted = false;
                    return true;
                }
            } catch (e) {}
            return false;
        }

        // 检查当前页是否是问答页
        // 是否 page-8 点击查看页：活跃页含 .p0806（<img class="element p0806 btn-next">，无 .btn-base/<a>）。
        // 站点把 .p0806 纳入 .btn-next 统一绑定（$(".btn-next").each → click 切页+callApinext）。
        static isPage8ClickPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                const act = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!act) return false;
                return !!(act.querySelector('.p0806, [class*="p0806"]'));
            } catch (_) { return false; }
        }

        // 是否 page-15 逐一点击互动页：活跃页含 .p1503~.p1509（createP15 7 组）。
        // 每组点 .p150N 或 .p150N-1 任一即计一组（同组 1000ms 动画锁）；7 组全点后站点显示 .page-15 .btn-base。
        static isPage15InteractPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                const act = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!act) return false;
                return !!(act.querySelector('.p1503, .p1504, .p1505, .p1506, .p1507, .p1508, .p1509, [class*="p150"]'));
            } catch (_) { return false; }
        }

        // 是否 page-3 逐点查看互动页：活跃页含 .p0301-N（P3btn 4 组）。每组需三连击
        // （.p0301-N → .p0304-N → .p0305-N），.p0304-N 需等站点 1400ms 动画才显示并绑定 click；
        // 4 组全完成后站点显示 .page-3 .btn-base。
        static isPage3InteractPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                const act = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!act) return false;
                return !!(act.querySelector('.p0301-1, .p0301-2, .p0301-3, .p0301-4, [class*="p0301-"]'));
            } catch (_) { return false; }
        }

        // 是否 page-16 选择互动页：活跃页含 .box[val]（3/5/10 分钟选项）或 .p1602。
        // 站点 JS：点 .box → 设置 .marn + 绑定 .p1602 点击；点 .p1602 → 1.5s 后 .page-16 .btn-base 显示。
        static isPage16SelectPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                const act = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!act) return false;
                return !!(act.querySelector('.box[val], [class*="box"][val], .p1602, [class*="p1602"]'));
            } catch (_) { return false; }
        }

        // 是否 scroll() 滚动揭示页（YueLia 模板 page-17~20）：活跃页含 .box1[7-9]/.box20 滚动箱 + .pXX03 触发按钮。
        // 站点 scroll(btn,box,page,img)：点 .pXX03 → img 淡出 + box 滚动到底(1600ms) → $(".page-N .btn-base") 显示，
        // 之后 .btn-base（btn-next）才可点翻页。btn-base 未显示前不能翻页（直接 trigger 隐藏 btn-next 会绕过
        // 滚动动画，站点互动未完成 → 翻页无效/风控）。
        static isScrollRevealPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                const act = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!act) return false;
                const hasBox = act.querySelector('.box17, .box18, .box19, .box20, [class*="box17"], [class*="box18"], [class*="box19"], [class*="box20"]');
                const hasTrig = act.querySelector('.p1703, .p1803, .p1903, .p2003, [class*="p1703"], [class*="p1803"], [class*="p1903"], [class*="p2003"]');
                return !!(hasBox && hasTrig);
            } catch (_) { return false; }
        }

        // 是否评论留言页（page-20 评论区）：活跃页含留言输入框/发布按钮。
        // 站点要求"发布留言成功"后才显示 .btn-base 翻页按钮（saveComment → $(".page-20 .btn-base").css("display","block")）。
        static isCommentPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                const act = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!act) return false;
                return !!(act.querySelector('.message-input, .message-submit, .message-input-area, #lxtext'));
            } catch (_) { return false; }
        }

        // 提交评论页留言：填安全内容 → 触发 input（站点启用发布按钮）→ 点击发布按钮。
        // 内容避开站点 checkSensitiveWords 敏感词列表（否则 showError 不发）。
        static submitComment(doc = document, content) {
            try {
                const act = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!act) return false;
                const input = act.querySelector('.message-input, #lxtext') || doc.querySelector('.message-input');
                const submit = act.querySelector('.message-submit') || doc.querySelector('.message-submit');
                if (!input || !submit) return false;
                const text = (typeof content === 'string' && content.trim()) ? content : '已认真学习，受益匪浅';
                try { input.value = text; } catch (_) {}
                try { input.dispatchEvent(new Event('input', { bubbles: true })); } catch (_) {}
                try { input.dispatchEvent(new Event('change', { bubbles: true })); } catch (_) {}
                try { if (typeof $ !== 'undefined') $(input).trigger('input'); } catch (_) {}
                // 站点 input handler 根据内容启用发布按钮；强制放开 disabled 后点击发布
                try { submit.disabled = false; } catch (_) {}
                try { if (typeof DOMUtils !== 'undefined' && DOMUtils.simulateClick) DOMUtils.simulateClick(submit); } catch (_) {}
                try { submit.click(); } catch (_) {}
                try { if (typeof $ !== 'undefined') $(submit).trigger('click'); } catch (_) {}
                return true;
            } catch (_) { return false; }
        }

        static isQuizPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                let activeSection = doc.querySelector('.page-item.page-active');
                if (!activeSection) activeSection = doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!activeSection) return false;
                // 课中观点题（page-19 投票题，name="ai19"）：无对错、投票显示百分比。
                // 已提交（选项 disabled / 百分比已显示）→ 非答题页，放行主循环翻页；
                // 否则观点题提交后页面停留显示百分比 + btn-next 可见，但 .dtx+radio 仍在 → isQuizPage 恒 true → 永久卡死。
                try {
                    const _vIn = activeSection.querySelector('input[name="ai19"]');
                    if (_vIn) {
                        const _allV = activeSection.querySelectorAll('input[name="ai19"]');
                        const _vDone = Array.from(_allV).some(function (i) { return i.disabled; });
                        if (_vDone) return false;
                    }
                } catch (_) {}
                // 新版编号页模板（btn-aq-n / btn-aq-y 结构）：section 内"正确/继续"按钮
                if (activeSection.querySelector && (activeSection.querySelector('.btn-aq-n, [class*="btn-aq-n"]') || activeSection.querySelector('.btn-aq-y, [class*="btn-aq-y"]'))) return true;
                return !!activeSection.querySelector('.dtx, .aq-item, .quiz-options, .pagedtx, input[type="checkbox"], input[type="radio"]');
            } catch (e) {
                return false;
            }
        }

        // 处理视频完成后的问答
        static handleVideoQuiz(doc = document) {
            return this.handleQuizSelection(doc) ? { action: 'processing' } : null;
        }

        /**
         * 判断 root 内是否存在"真实视频源"。
         * 新版图文课件模板（用户提供的 item.js 新版）在 page-0 用 xgplayer 建"空 URL 播放器桩"：
         *   BtnFn(".btn-start", ".page-start", ".page-0") → Hlsplay('mse', '')  // url 为空
         *   此时 xgplayer 会创建 <div class="xgplayer"><video src=""></video></div>，但 src 为空。
         * 这类"空 src 桩"不是真视频，不能因此把图文页误判成视频页（否则会被视频流程卡死）。
         * 规则：仅当存在带非空 src（含 blob:/http:/data:）的 <video>/<source> 或已加载元数据(duration>0)
         * 时才判定为真实视频。
         */
        static hasRealVideoSource(root) {
            if (!root || typeof root.querySelector !== 'function') return false;
            try {
                let v = null;
                try {
                    // root 本身可能就是 <video>（如被外部直接传入 video 元素）
                    const selfIsVideo = (root.tagName === 'VIDEO') || (root.nodeName === 'VIDEO') || (root._tag === 'video');
                    v = selfIsVideo ? root : root.querySelector('video');
                } catch (_) {
                    try { v = root.querySelector ? root.querySelector('video') : null; } catch (_2) { v = null; }
                }
                if (!v) return false;
                let src = '';
                try { src = (v.getAttribute && v.getAttribute('src')) || (v.currentSrc) || ''; } catch (_) { src = ''; }
                if (src && String(src).trim() && String(src) !== 'about:blank') return true;
                try {
                    const srcs = v.querySelectorAll ? v.querySelectorAll('source[src]') : [];
                    for (let i = 0; i < srcs.length; i++) {
                        const s = srcs[i].getAttribute ? srcs[i].getAttribute('src') : '';
                        if (s && String(s).trim()) return true;
                    }
                } catch (_) {}
                try { if (v.duration && v.duration > 0) return true; } catch (_) {}
            } catch (_) {}
            return false;
        }

        // 检测课程选择页面
        static isCourseSelectPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                return !!doc.querySelector('.comment-wklist, .wklist-item, [class*="wklist"]');
            } catch (e) {
                return false;
            }
        }

        // 查找下一课按钮
        static findNextCourseButton(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return null;
            try {
                const selectors = [
                    '.comment-wklist-item:not(.comment-wklist-item-finished) .comment-wklist-btn',
                    '.comment-wklist-item:not(.comment-wklist-item-finished)',
                    '[class*="wklist-item"]:not([class*="finished"])',
                    'a:contains("下一课")'
                ];
                for (const sel of selectors) {
                    try {
                        const btn = doc.querySelector(sel);
                        if (btn && btn.offsetParent !== null) {
                            return btn.closest('a') || btn;
                        }
                    } catch (e) {}
                }

                const allLinks = doc.querySelectorAll('a[href="javascript:;"]');
                for (const link of allLinks) {
                    if ((link.textContent || '').includes('下一课')) {
                        return link;
                    }
                }
            } catch (e) {}
            return null;
        }

        // 处理课程选择页面
        static handleCourseSelectPage(doc = document) {
            try {
                const nextBtn = this.findNextCourseButton(doc);
                if (nextBtn) {
                    // 【视频刷课不需要下一课】视频课程完成后停在当前页，不自动点"下一课"跳转下一门
                    // （用户明确要求）。图文课程不受影响，仍自动推进。
                    const videoDone = !!(State.videoCompleted && !State.graphicCompleted);
                    if (videoDone) {
                        try { Logger.info('视频课程已完成，不自动点击下一课（视频刷课不跳转）'); } catch (_) {}
                        return false;
                    }
                    Logger.info('点击下一课');
                    try { DOMUtils.simulateClick(nextBtn); } catch (e) {}
                    State.graphicCompleted = false;
                    State.videoCompleted = false;
                    State.hasClickedStart = false;
                    State.startBtnClickTime = null;
                    State.startBtnRetryCount = 0;
                    State.quizCompleted = false;
                    // 标记翻页中，等待 URL 真正变化后解锁
                    State.isPageTurning = true;
                    State.pageTurnTriggerTime = Date.now();
                    State.pageTurnTriggerSelector = '.comment-wklist-btn';
                    return true;
                }
            } catch (e) {
                try { Logger.debug(`handleCourseSelectPage 异常: ${e.message}`); } catch (_) {}
            }
            return false;
        }

        // 获取当前活跃 section 的索引
        // 【性能优化】支持传入已缓存 .page-item NodeList，避免主循环每轮重复全量查询
        static getActiveSectionIndex(doc = document, pageItems = null) {
            if (!doc || typeof doc.querySelectorAll !== 'function') return -1;
            try {
                const sections = Array.from(pageItems || doc.querySelectorAll('.page-item'));
                const validSections = sections.filter(s =>
                    !s.classList.contains('page-start') && !s.classList.contains('page-end')
                );
                for (let i = 0; i < validSections.length; i++) {
                    if (validSections[i].classList.contains('page-active')) {
                        return i;
                    }
                }
                for (let i = 0; i < sections.length; i++) {
                    if (sections[i].classList.contains('page-active')) {
                        return sections[i].classList.contains('page-start') ? -1 :
                               sections[i].classList.contains('page-end') ? validSections.length - 1 :
                               i;
                    }
                }
            } catch (e) {}
            return -1;
        }

        // 获取总 section 数量
        // 【性能优化】支持传入已缓存 .page-item NodeList，避免主循环每轮重复全量查询
        static getTotalSections(doc = document, pageItems = null) {
            if (!doc || typeof doc.querySelectorAll !== 'function') return 0;
            try {
                const sections = pageItems || doc.querySelectorAll('.page-item');
                let count = 0;
                for (const sec of sections) {
                    if (!sec.classList.contains('page-start') && !sec.classList.contains('page-end')) {
                        count++;
                    }
                }
                return count;
            } catch (e) {
                return 0;
            }
        }

        // 检测是否是课程列表页
        static isCourseListPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                if (!doc.querySelector('.van-collapse')) return false;
                if (doc.querySelector('.page-item')) return false;
                return doc.querySelectorAll('.img-texts-item').length > 0;
            } catch (e) {
                return false;
            }
        }

        // 在课程列表页选择第一个未完成的课程
        // DOM 结构（文档给出）：
        //   .van-collapse.van-hairline--top-bottom
        //     └ .van-collapse-item（每组课程）
        //         ├ .van-collapse-item__title  → 折叠头（点击展开）
        //         │   ├ .text   组名
        //         │   └ .count  "已完成/总数"
        //         └ .van-collapse-item__wrapper / .van-collapse-item__content
        //             └ ul.img-texts-list
        //                 └ li.img-texts-item.van-hairline--top （单课条目）
        //                     【已完成会额外带 class "passed"】
        //                     ├ img.img（封面）
        //                     ├ h5.title（课程名）
        //                     └ .social-group a.thumb-link（点赞数）
        static selectUnfinishedCourse(doc = document) {
            if (!doc || typeof doc.querySelectorAll !== 'function') return false;
            try {
                // 1) 优先：在已展开面板的内容中直接找第一个未 passed 的 li
                //    直接点击 li 本身（列表项）；站点会在其内部派发路由跳转。
                const directItems = doc.querySelectorAll('.van-collapse .img-texts-item');
                for (const item of directItems) {
                    if (!item || !item.classList) continue;
                    if (item.classList.contains('passed')) continue;
                    // 跳过仍处于折叠面板（wrapper display:none）中的 item：
                    // 不可见 item 点击可能不触发 SPA 路由，交给下方步骤 2 先展开再点击
                    try {
                        const wrap = item.closest('.van-collapse-item__wrapper');
                        if (wrap && wrap.style && /display\s*:\s*none/i.test(wrap.style.display || '')) continue;
                    } catch (_) {}
                    const titleEl = item.querySelector('.title, h5');
                    const titleText = (titleEl && (titleEl.textContent || '')).trim() || '';
                    Logger.info(`选择未完成课程: ${titleText}`);
                    // 优先点标题/封面（点击热区更稳定），兜底点整个 li
                    const target = item.querySelector('.title, h5, .img, img') || item;
                    try { DOMUtils.simulateClick(target); } catch (e) {}
                    return true;
                }

                // 2) 兜底：遍历折叠面板，按"未完成数>0"顺序依次展开 + 在其内容中找未 passed 条目
                //    （handleCourseListPage 已在调用方侧展开未完成组，但列表渲染有时晚于 select，
                //     这里补一次同轮尝试避免"空展开后找不到条目"的误报全部完成。）
                const collapseItems = doc.querySelectorAll('.van-collapse .van-collapse-item');
                for (const grp of collapseItems) {
                    if (!grp) continue;
                    // 计数：title 里的 "active / total"
                    const countWrap = grp.querySelector('.van-collapse-item__title .count');
                    let active = 0, total = 0;
                    if (countWrap) {
                        const m = (countWrap.textContent || '').match(/(\d+)\s*\/\s*(\d+)/);
                        if (m) { active = parseInt(m[1], 10); total = parseInt(m[2], 10); }
                    }
                    const notFinished = total > 0 && active < total;
                    // 折叠未展开 → 若未完成则展开
                    const titleEl = grp.querySelector(':scope > .van-collapse-item__title');
                    const isExpanded = !!grp.querySelector('.van-collapse-item__title--expanded, .van-collapse-item__title[aria-expanded="true"]');
                    if (!isExpanded && notFinished) {
                        if (titleEl) {
                            Logger.info(`展开未完成面板: ${(titleEl.querySelector('.text')?.textContent || '').trim() || ''}`);
                            try { DOMUtils.simulateClick(titleEl); } catch (_) {}
                        }
                    }
                    // 从当前 grp 中找 img-texts-item（可能藏在 wrapper/content 下，因此在 grp 内查）
                    const itemsInGroup = grp.querySelectorAll('.img-texts-item');
                    for (const item of itemsInGroup) {
                        if (!item || !item.classList) continue;
                        if (item.classList.contains('passed')) continue;
                        const title = (item.querySelector('.title, h5')?.textContent || '').trim() || '';
                        Logger.info(`选择未完成课程(组内): ${title}`);
                        const target = item.querySelector('.title, h5, .img, img') || item;
                        try { DOMUtils.simulateClick(target); } catch (_) {}
                        return true;
                    }
                }
            } catch (e) {
                try { Logger.debug(`selectUnfinishedCourse 异常: ${e.message}`); } catch (_) {}
            }
            return false;
        }
    }

    // ========== AI 答题模块 ==========
    class AIAnswer {
        static _abortController = null;  // 当前进行中的请求控制器

        // 检测是否在考试页面
        static isExamPage(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                // 检测 URL 参数
                const params = new URLSearchParams(window.location.search);
                const isExamRoute = (window.location.hash || '').includes('exam-page') ||
                                   (window.location.pathname || '').includes('exam') ||
                                   params.get('examId');
                if (isExamRoute) return true;

                // 检测 DOM 特征
                const hasStem = DOMUtils.query(doc, '.quest-stem, .question-stem, .exam-stem, [class*="question-stem"]');
                const hasOptions = DOMUtils.query(doc, '.quest-option, .quest-options, .question-option, .exam-option');

                if (hasStem && hasOptions) return true;

                // 检测明显的考试容器
                const examContent = DOMUtils.query(doc, '.exam-content, [class*="exam-paper"], [class*="exam-content"]');
                if (examContent && DOMUtils.query(examContent, '.quest-stem, .question-stem, [class*="quest-stem"]')) {
                    return true;
                }

                // 检测是否同时存在多个题目
                const multipleQuestions = doc.querySelectorAll('.quest-stem, .question-stem, [class*="quest-stem"]');
                if (multipleQuestions.length >= 2) {
                    return true;
                }
            } catch (e) {
                try { Logger.debug(`isExamPage 异常: ${e.message}`); } catch (_) {}
            }
            return false;
        }

        // 从页面解析当前题目和选项
        static parseQuestion(doc = document) {
            if (!doc || typeof doc.querySelector !== 'function') return null;
            try {
                const questStem = doc.querySelector('.quest-stem, .exam-content .quest-stem, [class*="stem"]');
                if (!questStem) return null;

                const question = (questStem.textContent || '').trim();
                if (!question) return null;

                const options = [];
                // 优先从选项容器内取精确选项项：避免 [class*="option"] 误匹配到
                // .quest-options(选项容器) 或 .mk-select-options(字体设置弹窗) 导致脏数据
                let optionItems = [];
                try {
                    const optsContainer = doc.querySelector('.quest-options, .question-options, .exam-options, [class*="quest-options"], [class*="question-options"]');
                    if (optsContainer && typeof optsContainer.querySelectorAll === 'function') {
                        optionItems = Array.from(optsContainer.querySelectorAll('.quest-option-item, .option-item, .question-option-item, .exam-option-item'));
                    }
                } catch (_) {}
                if (optionItems.length === 0) {
                    try {
                        optionItems = Array.from(doc.querySelectorAll('.quest-option-item, .option-item, .question-option-item, .exam-option-item'));
                    } catch (_) {}
                }

                for (let index = 0; index < optionItems.length; index++) {
                    const item = optionItems[index];
                    try {
                        const orderEl = item.querySelector('.order, [class*="order"]');
                        const order = orderEl ? (orderEl.textContent || '').trim() : String.fromCharCode(65 + index);
                        // 选项正文：只取该项文本并压缩空白，保证 hash 稳定（避免换行/缩进差异导致同题重复入库）
                        let content = (item.textContent || '').trim().replace(/\s+/g, ' ');
                        content = content.replace(/^[A-Z][\.、\s]*/, '').trim();
                        if (content) {
                            options.push({ order, content, index });
                        }
                    } catch (_) {}
                }

                if (options.length === 0) return null;
                return { question, options };
            } catch (e) {
                try { Logger.debug(`parseQuestion 异常: ${e.message}`); } catch (_) {}
                return null;
            }
        }

        // 获取所有选项的文本（用于发送给 AI）
        static formatOptionsForAI(options) {
            if (!Array.isArray(options) || options.length === 0) return '';
            return options.map(opt => `${opt.order || '?'}. ${opt.content || ''}`).join('\n');
        }

        // AI 无法答题（余额不足 / 未配置 API Key）时引导用户充值：
        // 弹窗提示跳转 http://mk.heymeta.cn/ 注册充值 + 使用方法，每个会话只提示一次（防刷屏）。
        static _promptAIRecharge() {
            try {
                if (State._aiRechargePrompted) return;
                State._aiRechargePrompted = true;
                try { Logger.warning('AI 答题不可用（余额不足或未配置 API Key）：请前往 http://mk.heymeta.cn/ 注册充值，在面板「AI 设置」填入 API Key'); } catch (_) {}
                try {
                    // 非阻塞浮层：不用 confirm（confirm 同步阻塞会卡死考试答题循环），页面右上角浮层提示 + 跳转按钮
                    const d = (typeof document !== 'undefined') ? document : null;
                    if (!d || !d.body) return;
                    if (d.getElementById('sk-ai-recharge-tip')) return;
                    const w = (typeof unsafeWindow !== 'undefined') ? unsafeWindow : window;
                    const div = d.createElement('div');
                    div.id = 'sk-ai-recharge-tip';
                    div.style.cssText = 'position:fixed;top:16px;right:16px;z-index:2147483647;background:#fff;border:1px solid #ff9f0a;border-radius:10px;box-shadow:0 6px 20px rgba(0,0,0,0.18);padding:12px 14px;max-width:300px;font:13px/1.6 -apple-system,"PingFang SC",sans-serif;color:#333;';
                    div.innerHTML =
                        '<div style="font-weight:600;color:#b4540a;margin-bottom:6px;">AI 答题余额不足</div>' +
                        '<div style="margin-bottom:8px;">未命中题库的题将无法自动作答。</div>' +
                        '<div style="margin-bottom:8px;">使用方法：<br>1. 前往 mk.heymeta.cn 注册登录<br>2. 充值获取 API Key<br>3. 面板「AI 设置」填入 API Key</div>' +
                        '<div style="display:flex;gap:8px;">' +
                        '<button id="sk-ai-recharge-go" style="flex:1;background:#ff9f0a;color:#fff;border:none;border-radius:6px;padding:6px 0;cursor:pointer;font-size:13px;">前往充值</button>' +
                        '<button id="sk-ai-recharge-close" style="flex:1;background:#f2f3f5;color:#666;border:none;border-radius:6px;padding:6px 0;cursor:pointer;font-size:13px;">知道了</button>' +
                        '</div>';
                    d.body.appendChild(div);
                    const goBtn = d.getElementById('sk-ai-recharge-go');
                    if (goBtn) {
                        goBtn.addEventListener('click', function () {
                            try { if (w && w.open) w.open('http://mk.heymeta.cn/', '_blank'); } catch (_) {}
                            try { if (div && div.remove) div.remove(); } catch (_) {}
                        });
                    }
                    const closeBtn = d.getElementById('sk-ai-recharge-close');
                    if (closeBtn) {
                        closeBtn.addEventListener('click', function () {
                            try { if (div && div.remove) div.remove(); } catch (_) {}
                        });
                    }
                    // 60s 自动消失，避免常驻页面
                    setTimeout(function () { try { if (div && div.remove) div.remove(); } catch (_) {} }, 60000);
                } catch (_) {}
            } catch (_) {}
        }

        // 生成题目唯一标识（用于缓存）
        static generateQuestionHash(question, options) {
            if (!question) return '0';
            // 只基于 题干 + 选项(order:content)，忽略 index 等元数据差异：
            // 同一道题无论解析出的 options 带不带 index，hash 必然一致，避免云端按 q_hash 去重失效产生重复记录
            const str = question + '|' + (Array.isArray(options) ? options.map(o => (o.order || '') + ':' + (o.content || '')).join('|') : '');
            let hash = 0;
            for (let i = 0; i < str.length; i++) {
                const char = str.charCodeAt(i);
                hash = ((hash << 5) - hash) + char;
                hash = hash & hash;
            }
            return hash.toString(36);
        }

        // 调用 AI 获取答案
        static async getAnswerFromAI(question, options) {
            // AI 来源路由：auto（云端优先→本地兜底）/ cloud（仅云端）/ local（仅本地）
            const srcCfg = (CONFIG && CONFIG.aiConfig) || {};
            const source = srcCfg.source || 'auto';
            const cloudOnly = source === 'cloud';
            const cloudReady = (typeof CloudAI !== 'undefined') && CloudAI.isAvailable();
            AIAnswer.lastSource = null; // 记录本次 AI 实际来源：'cloud' | 'local'
            if (source !== 'local' && cloudReady) {
                try {
                    const r = await CloudAI.query(question, options);
                    if (r && r.ok && r.answer) {
                        try { Logger.success(`云端 AI 答题结果: ${r.answer}`); } catch (_) {}
                        AIAnswer.lastSource = 'cloud';
                        return r.answer;
                    }
                    // 用户要求：AI 余额不足时应优先 query 云端题库接口（官方题库），而非直接回退本地 AI
                    try { Logger.warning(`云端 AI 未命中（${r && r.error ? r.error : '无结果'}），优先重查云端题库`); } catch (_) {}
                    try {
                        const qHash3 = AIAnswer.generateQuestionHash(question, options);
                        const cloud3 = await CloudBank.lookup(question, options, qHash3);
                        if (cloud3 && cloud3.record && cloud3.record.answer) {
                            try { Logger.info(`[题库] AI 未命中，云端题库命中[${cloud3.source}]: ${cloud3.record.answer}`); } catch (_) {}
                            AIAnswer.lastSource = 'cloud-bank';
                            return cloud3.record.answer;
                        }
                        try { Logger.warning('云端题库也未命中，回退本地 AI'); } catch (_) {}
                        // 云端 AI 余额不足且题库未命中：引导用户充值
                        try { AIAnswer._promptAIRecharge(); } catch (_) {}
                    } catch (e) {
                        try { Logger.warning(`云端题库重查失败: ${e?.message || e}`); } catch (_) {}
                    }
                    if (cloudOnly) return null;
                } catch (e) {
                    try { Logger.warning(`云端 AI 调用异常（${e && e.message}）${cloudOnly ? '' : '，回退本地 AI'}`); } catch (_) {}
                    if (cloudOnly) return null;
                }
            } else if (cloudOnly) {
                try { Logger.warning('云端 AI 不可用：未登录云端账户或云端服务未启用'); } catch (_) {}
                return null;
            }
            // ↓ 以下为本地 API Key 直连 LLM（source='local'，或云端未命中时回退至此） ↓
            const cfg = (CONFIG && CONFIG.aiConfig) || {};
            const apiUrl = cfg.apiUrl || CONFIG.aiApiUrl || 'http://api.mk.heymeta.cn';
            const apiKey = cfg.apiKey || (CONFIG && CONFIG.aiApiKey) || this.getAPIKeyFromFile();
            const model = cfg.model || (CONFIG && CONFIG.aiModel) || 'qwen-plus';
            const temperature = typeof cfg.temperature === 'number' ? cfg.temperature : 0.1;
            const maxTokens = cfg.maxTokens || 50;
            const timeout = cfg.timeout || CONFIG.aiTimeout || 30000;

            if (!apiKey) {
                Logger.error('未配置 API Key，请检查 AI 设置面板');
                // 引导用户前往 mk.heymeta.cn 注册充值
                try { AIAnswer._promptAIRecharge(); } catch (_) {}
                return null;
            }

            // 构造 prompt：使用默认模板或自定义模板
            const promptBody = (cfg.useDefaultPrompt === false && cfg.systemPrompt)
                ? cfg.systemPrompt
                : DEFAULT_SYSTEM_PROMPT;
            const prompt = promptBody
                .replace('{question}', String(question || ''))
                .replace('{options}', this.formatOptionsForAI(options));

            // 取消上一次未完成的请求
            try {
                if (this._abortController) this._abortController.abort();
            } catch (_) {}
            this._abortController = new AbortController();
            const controller = this._abortController;

            try {
                Logger.debug(`正在请求 AI 答题...`);

                const response = await HttpUtil.request(`${apiUrl}/chat/completions`, {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                        'Authorization': `Bearer ${apiKey}`
                    },
                    body: JSON.stringify({
                        model: model,
                        messages: [
                            { role: 'user', content: prompt }
                        ],
                        max_tokens: maxTokens,
                        temperature: temperature
                    }),
                    signal: controller.signal,
                    timeout: timeout,
                });

                if (!response.ok) {
                    throw new Error(`API 请求失败: ${response.status}`);
                }

                const data = await response.json();
                let answer = '';

                try {
                    if (data?.choices?.[0]?.message?.content) {
                        answer = String(data.choices[0].message.content).trim();
                    } else if (data?.output?.text) {
                        answer = String(data.output.text).trim();
                    } else {
                        answer = JSON.stringify(data);
                    }
                } catch (e) {
                    answer = '';
                }

                // 提取选项字母
                const answerMatch = answer.match(/([A-Z](?:[,\s]*[A-Z])*)/i);
                if (answerMatch) {
                    answer = answerMatch[1].toUpperCase();
                }

                if (answer) {
                    Logger.success(`AI 答题结果: ${answer}`);
                } else {
                    Logger.warning('AI 答题结果为空');
                }
                if (answer) AIAnswer.lastSource = 'local';
                return answer;

            } catch (error) {
                if (error?.name === 'AbortError') {
                    Logger.debug('AI 答题请求被取消');
                    return null;
                }
                Logger.error(`AI 答题失败: ${error?.message || error}`);
                return null;
            } finally {
                if (this._abortController === controller) {
                    this._abortController = null;
                }
            }
        }

        // 从 apikey.md 获取 API Key
        static getAPIKeyFromFile() {
            try {
                const apikeyEl = document.getElementById('apikey-content');
                if (apikeyEl) {
                    const text = apikeyEl.textContent || '';
                    const match = text.match(/sk-[A-Za-z0-9\-\.]+/);
                    if (match) return match[0];
                }
            } catch (e) {}
            return '';
        }

        // 选择答案选项
        static selectAnswer(doc, answerLetters) {
            if (!doc || typeof doc.querySelectorAll !== 'function') return;
            if (!answerLetters) return;
            try {
                // 兼容多选答案两种格式："C,D"(逗号) 与 "CD"(连写) —— 连写需拆成单字母逐项勾选
                const rawLetters = String(answerLetters).toUpperCase().replace(/[^A-Z,]/g, '');
                const letters = rawLetters.includes(',')
                    ? rawLetters.split(',').filter(Boolean)
                    : rawLetters.split('').filter(Boolean);
                if (letters.length === 0) return;

                const optionItems = doc.querySelectorAll('.quest-option-item');
                for (const letter of letters) {
                    for (const item of optionItems) {
                        try {
                            const orderEl = item.querySelector('.order');
                            const order = orderEl ? (orderEl.textContent || '').trim() : '';
                            if (order.toUpperCase() === letter) {
                                try { item.click(); } catch (e) {}
                                Logger.debug(`已选择选项: ${letter}`);
                                break;
                            }
                        } catch (_) {}
                    }
                }
            } catch (e) {
                try { Logger.debug(`selectAnswer 异常: ${e.message}`); } catch (_) {}
            }
        }

        // 提交答案
        static submitAnswer(doc) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                const submitBtn = doc.querySelector('.btn-submit, .btn-confirm, [class*="submit"], [class*="confirm"]');
                if (submitBtn && submitBtn.offsetParent !== null) {
                    try { DOMUtils.simulateClick(submitBtn); } catch (e) {}
                    Logger.debug('已提交答案');
                    return true;
                }
            } catch (e) {}
            return false;
        }

        // 处理单道题目
        static async handleSingleQuestion(doc) {
            if (!doc) return false;
            try {
                const questionData = this.parseQuestion(doc);
                if (!questionData) {
                    Logger.debug('无法解析题目，检查 DOM 结构...');
                    return false;
                }

                const questionHash = this.generateQuestionHash(questionData.question, questionData.options);
                Logger.info(`题目: ${(questionData.question || '').substring(0, 80)}...`);
                Logger.info(`选项数量: ${questionData.options.length}`);

                // 1) 运行时内存缓存（最高优先级，避免重复点击）
                if (State.aiAnswerCache && State.aiAnswerCache.has(questionHash)) {
                    const cachedAnswer = State.aiAnswerCache.get(questionHash);
                    Logger.info(`使用缓存答案: ${cachedAnswer}`);
                    this.selectAnswer(doc, cachedAnswer);
                    await new Promise(resolve => setTimeout(resolve, 500));
                    return true;
                }

                let answer = null;
                let answerSource = null; // local | cloud | ai

                // 2) 本地题库（精确 hash → 模糊题干）
                try {
                    const localRec = QuestionBank.findByHash(questionHash) || QuestionBank.findFuzzy(questionData.question, questionData.options);
                    if (localRec && localRec.answer) {
                        answer = localRec.answer;
                        answerSource = 'local';
                        QuestionBank.recordHit('localHits');
                        Logger.info(`命中本地题库: ${answer}`);
                    }
                } catch (e) {}

                // 3) 云端题库（如果启用且本地未命中）——先于 AI，优先官方题库
                if (!answer && CloudBank.isEnabled() && (CONFIG.cloudBank?.queryBeforeAI !== false)) {
                    try { Logger.debug('[题库] 查询云端题库（官方题库优先于 AI）'); } catch (_) {}
                    try {
                        const cloud = await CloudBank.lookup(questionData.question, questionData.options, questionHash);
                        if (cloud && cloud.record && cloud.record.answer) {
                            answer = cloud.record.answer;
                            answerSource = 'cloud';
                            QuestionBank.recordHit('cloudHits');
                            Logger.info(`命中云端题库[${cloud.source}]: ${answer}`);
                            // 反向缓存到本地
                            try {
                                QuestionBank.upsert({
                                    qHash: cloud.record.qHash || questionHash,
                                    question: cloud.record.question || questionData.question,
                                    options: cloud.record.options || questionData.options,
                                    answer: cloud.record.answer,
                                    type: cloud.record.type || 'single',
                                    source: 'local',
                                    verified: !!cloud.record.verified,
                                    createdAt: cloud.record.createdAt,
                                    updatedAt: cloud.record.updatedAt
                                });
                            } catch (_) {}
                        }
                    } catch (e) {
                        try { Logger.debug(`云端查询异常: ${e?.message || e}`); } catch (_) {}
                    }
                    if (!answer) {
                        try { Logger.debug('[题库] 云端题库未命中，转 AI 兜底'); } catch (_) {}
                    }
                }

                // 4) 调用 AI（兜底）
                if (!answer) {
                    answer = await this.getAnswerFromAI(questionData.question, questionData.options);
                    if (answer) {
                        answerSource = 'ai';
                        QuestionBank.recordHit('aiHits');
                    }
                }

                if (answer) {
                    if (State.aiAnswerCache) State.aiAnswerCache.set(questionHash, answer);
                    State.aiAnswerSuccess = (State.aiAnswerSuccess || 0) + 1;
                    // 答题结果统计：成功
                    try { if (typeof QuestionBank !== 'undefined' && QuestionBank.recordAnswer) QuestionBank.recordAnswer(true); } catch (_) {}
                    this.selectAnswer(doc, answer);
                    this.saveAnswerToLocal(questionData.question, questionData.options, answer);

                    // 推送"最近一次答题"到面板（让题库 Tab 的"最近答题"实时更新）
                    try {
                        if (typeof window !== 'undefined' && window.shuakePanelInstance && typeof window.shuakePanelInstance._renderLastBankAnswer === 'function') {
                            window.shuakePanelInstance._renderLastBankAnswer({
                                question: questionData.question,
                                answer: answer,
                                source: answerSource || 'local',
                                at: new Date().toISOString()
                            });
                        }
                    } catch (_) {}

                    // AI 答出的题异步上传到云端（不阻塞 UI）
                    if (answerSource === 'ai' && CloudBank.isEnabled() && CONFIG.cloudBank?.autoUpload) {
                        Promise.resolve().then(async () => {
                            try {
                                const record = QuestionBank.normalize({
                                    qHash: questionHash,
                                    question: questionData.question,
                                    options: questionData.options,
                                    answer: answer,
                                    type: 'single',
                                    source: 'ai'
                                });
                                if (record) {
                                    const res = await CloudBank.upload(record);
                                    if (res && res.ok) {
                                        try { Logger.debug(`云端上传: ${res.action || 'ok'}`); } catch (_) {}
                                    }
                                }
                            } catch (e) {
                                try { Logger.debug(`云端上传异常: ${e?.message || e}`); } catch (_) {}
                            }
                        });
                    }

                    await new Promise(resolve => setTimeout(resolve, 500));
                    return true;
                } else {
                    State.aiAnswerFailed = (State.aiAnswerFailed || 0) + 1;
                    // 答题结果统计：失败
                    try { if (typeof QuestionBank !== 'undefined' && QuestionBank.recordAnswer) QuestionBank.recordAnswer(false); } catch (_) {}
                    return false;
                }
            } catch (e) {
                try { Logger.debug(`handleSingleQuestion 异常: ${e.message}`); } catch (_) {}
                return false;
            }
        }

        // 检测是否有下一题按钮
        static hasNextQuestion(doc) {
            if (!doc || typeof doc.querySelectorAll !== 'function') return null;
            try {
                const allButtons = doc.querySelectorAll('button, a');
                for (const btn of allButtons) {
                    const text = (btn.textContent || '').trim();
                    if (text === '下一题' && !btn.disabled) {
                        return btn;
                    }
                }
            } catch (e) {}
            return null;
        }

        // 检测是否已完成所有题目
        static isExamFinished(doc) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                const finishPatterns = [
                    '.exam-finished', '.exam-complete', '.result-page',
                    '[class*="finished"]', '[class*="complete"]',
                    '已提交', '已完成', '答题完成'
                ];
                for (const pattern of finishPatterns) {
                    if (doc.querySelector(pattern)) return true;
                }
                const scoreEl = doc.querySelector('[class*="score"], [class*="result"]');
                return !!scoreEl;
            } catch (e) {}
            return false;
        }

        // 找文本匹配的可见按钮（Mint UI / Vue 考试页通用）
        static _findTextButton(doc, regex, excludeRe, allowDisabled) {
            if (!doc || typeof doc.querySelectorAll !== 'function') return null;
            try {
                const cands = doc.querySelectorAll('button, a, [role="button"], [class*="mint-button"], [class*="btn"]');
                for (const b of cands) {
                    try {
                        const t = (b.textContent || '').trim();
                        if (!regex.test(t)) continue;
                        if (excludeRe && excludeRe.test(t)) continue;
                        const visible = (typeof b.offsetParent !== 'undefined') ? b.offsetParent !== null : true;
                        const disabled = (b.disabled === true) || /is-disabled/.test(b.className || '');
                        if (visible && (allowDisabled || !disabled)) return b;
                    } catch (_) {}
                }
            } catch (_) {}
            return null;
        }

        // 交卷后可能弹出确认框（含 .confirm-message "共50道题，还有0道未作答" + 确认按钮），
        // 延时自动点"确认交卷"；仍有未作答时跳过（继续答题）。
        static _confirmSubmit(doc) {
            setTimeout(() => {
                try {
                    if (!doc || typeof doc.querySelector !== 'function') return;
                    // 确认框特征：.confirm-message 元素 或 页面文本含"未作答"
                    const hasBox = !!doc.querySelector('.confirm-message, [class*="confirm-message"]')
                        || /未作答/.test((doc.body && doc.body.textContent) || '');
                    if (!hasBox) {
                        Logger.debug('未检测到交卷确认框');
                        return;
                    }
                    const confirmBtn = this._findTextButton(doc, /确认交卷|确定交卷|确认提交|确认无误|交卷/, /取消|关闭|上一题|下一题|答题卡|剩余时间|再检查|暂不/, true);
                    if (confirmBtn) {
                        const disabled = (confirmBtn.disabled === true) || /is-disabled/.test(confirmBtn.className || '');
                        if (disabled) {
                            Logger.warning('交卷确认不可用：仍有题目未作答，继续答题');
                            return;
                        }
                        try { DOMUtils.simulateClick(confirmBtn); } catch (e) {}
                        Logger.success('已确认交卷');
                    } else {
                        Logger.debug('确认框内未找到确认交卷按钮');
                    }
                } catch (_) {}
            }, 1500);
        }

        // 提交考试（适配 Mint UI 结课考试页：交卷入口在"查看答题卡"弹窗内）
        static submitExam(doc) {
            if (!doc || typeof doc.querySelector !== 'function') return false;
            try {
                // 1) 类选择器（旧模板）
                let submitBtn = doc.querySelector('.btn-submit-exam, .btn-submit-paper, [class*="submit-exam"], [class*="submit-paper"]');
                // 2) 文本匹配交卷按钮（Mint UI / Vue 常见文案，含弹窗内；allowDisabled 以便识别"有题未答"）
                if (!submitBtn) {
                    submitBtn = this._findTextButton(doc, /交卷|提交试卷|完成考试|确定交卷|确认交卷|提交考试|立即交卷|交卷并提交|提交并交卷|交卷并退出|提交答卷/, /答题卡|上一题|下一题|剩余时间|取消|关闭/, true);
                }
                if (submitBtn) {
                    const disabled = (submitBtn.disabled === true) || /is-disabled/.test(submitBtn.className || '');
                    if (disabled) {
                        Logger.warning('交卷按钮不可用：存在未作答的题目，继续答题');
                        return false;
                    }
                    try { DOMUtils.simulateClick(submitBtn); } catch (e) {}
                    Logger.success('已提交考试，等待确认框');
                    this._confirmSubmit(doc);
                    return true;
                }
                // 3) 交卷入口在"查看答题卡"弹窗内：打开答题卡（防重 30s），随后定时器自动在弹窗内找交卷
                if (!State._examCardOpened) {
                    const cardBtn = this._findTextButton(doc, /查看答题卡|答题卡/, /上一题|下一题|剩余时间|取消|关闭/);
                    if (cardBtn) {
                        State._examCardOpened = true;
                        try { DOMUtils.simulateClick(cardBtn); } catch (e) {}
                        Logger.debug('已打开答题卡，将在弹窗内查找交卷按钮');
                        setTimeout(() => { try { State._examCardOpened = false; } catch (_) {} }, 30000);
                        // 弹窗动画后自动在弹窗内找交卷按钮点击（不依赖下一次 processExamPage 触发）
                        setTimeout(() => {
                            try {
                                const popBtn = this._findTextButton(doc, /交卷|提交试卷|完成考试|确定交卷|确认交卷|提交考试|交卷并提交|提交并交卷|交卷并退出|提交答卷/, /答题卡|上一题|下一题|剩余时间|取消|关闭/, true);
                                if (popBtn) {
                                    const pd = (popBtn.disabled === true) || /is-disabled/.test(popBtn.className || '');
                                    if (!pd) {
                                        try { DOMUtils.simulateClick(popBtn); } catch (e) {}
                                        Logger.success('已通过答题卡弹窗提交考试，等待确认框');
                                        this._confirmSubmit(doc);
                                    } else {
                                        Logger.warning('答题卡内交卷按钮不可用：存在未作答题目');
                                    }
                                } else {
                                    Logger.debug('答题卡弹窗内未找到交卷按钮');
                                }
                            } catch (_) {}
                        }, 2500);
                        return true;
                    }
                }
            } catch (e) {}
            return false;
        }

        // 主考试处理流程
        static async processExamPage(doc) {
            try {
                if (!CONFIG.enableAIAnswer) {
                    return;
                }
                if (!State.isRunning) {
                    return;
                }
                if (State.aiProcessing) {
                    return;
                }
                if (!this.isExamPage(doc)) {
                    return;
                }

                State.isExamPage = true;
                State.aiProcessing = true;
                Logger.info('进入考试页面');

                if (this.isExamFinished(doc)) {
                    Logger.success('考试已完成');
                    State.aiProcessing = false;
                    return;
                }

                // 交卷确认 sheet（最后一题点"下一题"后站点自动弹出：
                // .confirm-sheet "共50道题，还有X道未作答" + 底部"交卷"按钮）→ 优先识别并交卷，避免卡在答题死循环
                try {
                    const sheetBox = doc.querySelector('.confirm-sheet, [class*="confirm-sheet"], .confirm-message, [class*="confirm-message"]');
                    if (sheetBox) {
                        const subBtn = this._findTextButton(doc, /交卷|确认交卷|确定交卷|确认提交|提交试卷|立即交卷/, /查看答题卡|答题卡|取消|关闭|上一题|下一题/, true);
                        if (subBtn) {
                            const sd = (subBtn.disabled === true) || /is-disabled/.test(subBtn.className || '');
                            if (!sd) {
                                try { DOMUtils.simulateClick(subBtn); } catch (e) {}
                                Logger.success('已识别交卷确认框并提交考试');
                                // 可能还有二次确认（.confirm-message 再弹），交给 _confirmSubmit
                                this._confirmSubmit(doc);
                            } else {
                                Logger.warning('交卷确认框交卷按钮不可用：存在未作答题目');
                            }
                        } else {
                            Logger.warning('已打开交卷确认框但未找到交卷按钮');
                        }
                        State.aiProcessing = false;
                        return;
                    }
                } catch (_) {}

                await this.handleSingleQuestion(doc);

                setTimeout(() => {
                    try {
                        if (!State.isRunning) {
                            State.aiProcessing = false;
                            return;
                        }
                        this.clickNextQuestion(doc);
                        setTimeout(() => {
                            State.aiProcessing = false;
                        }, 500);
                    } catch (e) {
                        State.aiProcessing = false;
                    }
                }, 2000);
            } catch (e) {
                State.aiProcessing = false;
                try { Logger.debug(`processExamPage 异常: ${e.message}`); } catch (_) {}
            }
        }

        // 保存答案到本地（规范化题库 + 兼容旧格式）
        static saveAnswerToLocal(question, options, answer) {
            try {
                if (!question) return;
                const qHash = this.generateQuestionHash(question, options);
                QuestionBank.upsert({
                    qHash,
                    question: String(question),
                    options: Array.isArray(options) ? options : [],
                    answer: String(answer || ''),
                    type: 'single',
                    source: 'local'
                });
                Logger.debug('答案已保存到本地题库');
            } catch (e) {
                try { Logger.debug('保存答案失败: ' + (e?.message || e)); } catch (_) {}
            }
        }

        // 从本地获取答案（先按 hash 精确查找，再按题干兼容查找）
        static getLocalAnswer(question, options) {
            try {
                if (!question) return null;
                const hash = this.generateQuestionHash(question, options);
                const rec = QuestionBank.findByHash(hash) || QuestionBank.findByQuestion(question);
                if (!rec) return null;
                return {
                    question: rec.question,
                    options: rec.options || [],
                    answer: rec.answer || ''
                };
            } catch (e) {
                return null;
            }
        }

        // 点击下一题
        static clickNextQuestion(doc) {
            try {
                // 最后一题点"下一题"后 Vue/Mint UI 常弹"确认交卷"确认框：优先点确认，避免卡在弹窗
                try {
                    const confirmBtn = this._findTextButton(doc, /确认交卷|确定交卷|确认提交|确定交卷|确认无误，交卷|确认交卷并提交|提交试卷|交卷并提交|提交并交卷|交卷并退出/, /取消|关闭|上一题|下一题|答题卡/);
                    if (confirmBtn) {
                        try { DOMUtils.simulateClick(confirmBtn); } catch (e) {}
                        Logger.success('已点击确认交卷');
                        return;
                    }
                } catch (_) {}
                const nextBtn = this.hasNextQuestion(doc);
                if (nextBtn) {
                    try { DOMUtils.simulateClick(nextBtn); } catch (e) {}
                    Logger.debug('点击下一题');
                    setTimeout(() => {
                        try { this.processExamPage(doc); } catch (_) {}
                    }, 2000);
                } else {
                    Logger.debug('未找到下一题按钮，尝试提交考试');
                    this.submitExam(doc);
                }
            } catch (e) {
                try { Logger.debug(`clickNextQuestion 异常: ${e.message}`); } catch (_) {}
            }
        }
    }

    // ========== 主控制器 ==========
    // 数据窃听监听：站点同源调 weiban API 一定能成功（绕过脚本自身跨域 CORS），是最可靠的数据源。
    // 抽成共享函数，供「库加载前预安装」与「控制器构造」两处幂等调用（同 pattern 注册会覆盖，无重复触发）。
    function registerDataEavesdrop() {
        try {
            // 0) 登录响应窃听：login.do 返回最新 token（每次登录都会更新），持久化供跨页/跨域使用
            AjaxHooker.on(/login\.do/i, (phase, config, body) => {
                if (phase !== 'response' || !body) return;
                try {
                    const d = body.data;
                    if (body.code === '0' && d && (d.token || d.jwtToken)) {
                        if (d.token) {
                            window.__authToken = String(d.token);
                            AjaxHooker._tokens.set('x-token', String(d.token));
                            AjaxHooker._tokens.set('token', String(d.token));
                        }
                        // 同步到本地登录态缓存（供 readStoredUser/readStoredToken 兜底）
                        try {
                            const cur = readStoredUser();
                            const merged = Object.assign({}, cur || {}, d);
                            localStorage.setItem('shuake_bridged_user', JSON.stringify(merged));
                        } catch (_) {}
                        try { Logger.info(`[窃听] 登录响应已刷新 token`); } catch (_) {}
                    }
                } catch (_) {}
            });
            // 【试卷预解析】拦截 startPaper.do：站点开始考试时一次返回全卷题目 → 预取 + 本地预解析答案
            AjaxHooker.on(/startPaper\.do/i, (phase, config, body) => {
                if (phase !== 'response' || !body) return;
                try {
                    const d = body.data;
                    if (body.code === '0' && d && Array.isArray(d.questionList) && d.questionList.length > 0) {
                        try { if (typeof ExamPaper !== 'undefined') ExamPaper.reset(); } catch (_) {}
                        if (typeof ExamPaper !== 'undefined') {
                            const n = ExamPaper.ingest(d);
                            if (n > 0) ExamPaper.preResolve();
                        }
                        try { Logger.info(`[窃听] startPaper：试卷 ${(d.questionList || []).length} 题已预取`); } catch (_) {}
                    }
                } catch (_) {}
            });
            AjaxHooker.on(/listCategory\.do/i, (phase, config, body) => {
                if (phase !== 'response' || !body) return;
                try {
                    if (body.code === '0' && Array.isArray(body.data) && body.data.length > 0) {
                        CategoryInfo.data = normalizeCategories(body.data);
                        DataCache.save('category', CategoryInfo.data);
                        Logger.info(`[窃听] 课程分类 ${body.data.length} 个，未完成 ${CategoryInfo.data.filter(c => c.status !== 'done').length} 个`);
                        try { window.shuakePanelInstance?.refreshCoursePanel(); } catch (_) {}
                    }
                } catch (_) {}
            });
            AjaxHooker.on(/listPrePlan\.do/i, (phase, config, body) => {
                if (phase !== 'response' || !body) return;
                try {
                    const d = body.data;
                    if (body.code === '0' && d && d.hasPreExam === 1 && Array.isArray(d.examList)) {
                        ExamManager.data = d.examList.map((e) => ({
                            examPlanId: e.examPlanId || e.id || '',
                            examId: e.examId || '',
                            examName: e.examName || e.name || '考试',
                            examStatus: e.examStatus || e.status || '未知',
                            examStartTime: e.examStartTime || '',
                            examEndTime: e.examEndTime || '',
                            limitTime: e.limitTime || 0,
                            canExam: e.canExam || 0,
                            raw: e
                        }));
                        DataCache.save('exam', ExamManager.data);
                        Logger.info(`[窃听] 考试列表 ${ExamManager.data.length} 个`);
                        try { window.shuakePanelInstance?.refreshCoursePanel(); } catch (_) {}
                    }
                } catch (_) {}
            });
            AjaxHooker.on(/listPlan\.do/i, (phase, config, body) => {
                if (phase !== 'response' || !body) return;
                try {
                    if (body.code === '0' && Array.isArray(body.data) && body.data.length > 0) {
                        const plans = body.data.map((e) => ({
                            id: e.id || e.examPlanId || e.examId || '',
                            examPlanId: e.examPlanId || e.id || '',
                            userExamPlanId: e.id || e.examPlanId || '',
                            examId: e.examId || '',
                            examName: e.examPlanName || e.examName || e.name || '考试',
                            examStatus: e.examStatus || e.status || '待考',
                            examStartTime: e.startTime || e.examStartTime || '',
                            examEndTime: e.endTime || e.examEndTime || '',
                            limitTime: e.answerTime || e.limitTime || 0,
                            passScore: e.passScore || 0,
                            answerNum: e.answerNum || 0,
                            canExam: e.canExam || 0,
                            examScore: e.examScore || 0,
                            type: 'plan',
                            raw: e
                        }));
                        // 与已缓存的预考合并（避免覆盖预考）
                        const existing = Array.isArray(ExamManager.data) ? ExamManager.data.filter((x) => x.type === 'pre') : [];
                        ExamManager.data = existing.concat(plans);
                        DataCache.save('exam', ExamManager.data);
                        Logger.info(`[窃听] 考试列表 ${ExamManager.data.length} 个（含结课考试）`);
                        try { window.shuakePanelInstance?.refreshCoursePanel(); } catch (_) {}
                    }
                } catch (_) {}
            });
            AjaxHooker.on(/showProgress\.do/i, (phase, config, body) => {
                if (phase !== 'response' || !body) return;
                try {
                    if (body.code === '0' && body.data) {
                        ProjectInfo.data = body.data;
                        DataCache.save('project', body.data);
                        Logger.info(`[窃听] 项目进度 ${body.data.name || ''}`);
                        try { window.shuakePanelInstance?.refreshCoursePanel(); } catch (_) {}
                    }
                } catch (_) {}
            });
            AjaxHooker.on(/getCourse\.do/i, (phase, config, body) => {
                if (phase !== 'response' || !body) return;
                try {
                    if (body.code === '0' && body.data) {
                        CourseInfo.data = body.data;
                        DataCache.save('course', body.data);
                        Logger.info(`[窃听] 课程信息 ${body.data.name || body.data.courseName || ''}`);
                        try { window.shuakePanelInstance?.updateCourseInfo(CourseInfo.getDisplayInfo()); } catch (_) {}
                    }
                } catch (_) {}
            });
        } catch (_) {}
    }

    // ========== Canvas 微课（CreateJS 动画课）适配 ==========
    // 适用：shareList 列出的 wkzy.mycourse.cn/9080/<hash>/<id>.html 等 Canvas 微课。
    // 结构：<canvas id="canvas"> + lib.<id> 动画 + window.exportRoot；动画在多个交互帧 stop()
    //       等待点击推进，末帧自动调用 finishWxCourse() 上报完成并显示"返回列表"按钮。
    // 已核实（A15005 / A15004 / A05024）三种交互按钮模型：
    //   - 推进按钮：Dian(继续) / xia(下一) / nextBtn、nextBtnN(下一页，点击后 play())
    //   - 判断题：Dui* (对 → dd → 推进)；Cuo* (错 → dc → 部分课程会 fan 重答循环) —— 只点"对"
    //   - 多选题：a1-a4 (选项) + tijiao (提交)，全选后提交 → dd (正确)；只选部分 → dc → 重答
    //   - 错误/回退按钮：fan(返/重答) / prevBtn*(上一页) —— 绝不点击
    //   - 结束：fanhuiliebiao(返回列表) 出现在末帧（finishWxCourse 已由动画自身触发）
    // 判定"当前可交互按钮"：对象仍在舞台上（parent === root）且当前绑定了 click 监听
    // （每帧 frame 脚本先 removeAllEventListeners 再按帧绑定），不依赖 _off（多数按钮无 _off tween）。
    const CanvasCourse = {
        readyLogged: false,   // 是否已提示"等待动画加载"
        doneLogged: false,    // 是否已提示"完成学习"
        lastClickAt: 0,       // 防抖：相邻两次点击最小间隔
        minClickGap: 900,
        backClicked: false,   // 完成后是否已点击"返回列表"
        backAt: 0,            // 记录完成时刻（用于延迟后自动返回）

        // 兼容多种 canvas 课件特征：
        //   · <canvas id="canvas">（Animate HTML5 导出默认）
        //   · 任意 <canvas> 且页面存在 CreateJS 全局（exportRoot/lib/cjs）→ 判定为 canvas 微课
        //   · 无 canvas 但存在 exportRoot（个别课件 canvas 未渲染完成前 exportRoot 已挂载）
        isCanvasPage(doc) {
            try {
                if (!doc || typeof doc.querySelector !== 'function') return false;
                // 1) 经典：canvas#canvas / #canvas
                if (doc.querySelector('canvas#canvas, #canvas')) return true;
                // 2) 任意可见 canvas + CreateJS 特征（cjs/lib/exportRoot）
                const hasCjsGlobal = !!(doc.defaultView
                    && (doc.defaultView.exportRoot || doc.defaultView.cjs || doc.defaultView.createjs));
                if (doc.querySelector('canvas') && (hasCjsGlobal || this.root(doc))) return true;
                // 3) 无 canvas 但 exportRoot 已挂载（canvas 尚未渲染/隐藏）——仍按 canvas 微课处理
                if (this.root(doc)) return true;
            } catch (_) {}
            return false;
        },

        // 取 CreateJS 动画根对象 exportRoot；多上下文 + 多命名兜底：
        //   优先从 doc.defaultView（iframe 内 doc 与脚本 window 可能不同上下文），
        //   再遍历常见全局命名（exportRoot/root/stage/canvasStage/_root/libRoot），
        //   最后回退 window.exportRoot。
        root(doc) {
            try {
                const w = (doc && doc.defaultView) ? doc.defaultView : window;
                const r0 = w.exportRoot;
                if (r0 && typeof r0.gotoAndPlay === 'function') return r0;
                // 兜底：遍历常见命名（部分 Canvas 微课挂在闭包/别的全局名）
                try {
                    for (const k of Object.keys(w)) {
                        if (/^(exportRoot|root|stage|canvasStage|_root|libRoot)$/i.test(k)) {
                            const v = w[k];
                            if (v && typeof v.gotoAndPlay === 'function') return v;
                        }
                    }
                } catch (_) {}
                // 兜底：window.exportRoot（脚本注入上下文）
                try {
                    const r2 = window.exportRoot;
                    if (r2 && typeof r2.gotoAndPlay === 'function') return r2;
                } catch (_) {}
            } catch (_) {}
            return null;
        },

        // 判定某按钮当前是否"可交互"：在舞台上（parent === root）且绑定了 click 监听
        isActive(root, name) {
            try {
                const b = root[name];
                if (!b) return false;
                if (b.parent !== root) return false;                 // 已从舞台移除
                if (typeof b.hasEventListener !== 'function') return false;
                return !!b.hasEventListener('click');                // 当前帧绑定了 click
            } catch (_) { return false; }
        },

        // 匹配当前可交互按钮并返回动作类型
        //   'end'  -> 已完成（fanhuiliebiao 可见）
        //   'quiz-multi' -> 多选题（a1-a4 + tijiao，全选后提交）
        //   'dui'  -> 判断题点"对"
        //   'adv'  -> 推进按钮（Dian/xia/nextBtn*）
        //   null   -> 无
        currentAction(root) {
            try {
                // 1) 结束帧
                if (this.isActive(root, 'fanhuiliebiao')) return 'end';
                // 2) 多选题（出现 a1 选项即多选答题帧）
                if (this.isActive(root, 'a1')) return 'quiz-multi';
                // 3) 判断题"对"
                const keys = Object.keys(root);
                for (const k of keys) {
                    if (k === 'Dui' || /^Dui\d+$/.test(k)) {
                        if (this.isActive(root, k)) return 'dui';
                    }
                }
                // 4) 推进按钮（优先 Dian/xia，其次 nextBtn*）
                for (const k of ['Dian', 'xia']) {
                    if (this.isActive(root, k)) return 'adv';
                }
                for (const k of keys) {
                    if (k === 'nextBtn' || /^nextBtn\d+$/.test(k)) {
                        if (this.isActive(root, k)) return 'adv';
                    }
                }
            } catch (_) {}
            return null;
        },

        // 点击某按钮（dispatchEvent 直接触发 CreateJS 监听器，无需命中舞台坐标）
        fire(root, name) {
            try {
                const b = root[name];
                if (b && typeof b.dispatchEvent === 'function') {
                    b.dispatchEvent('click');
                    return true;
                }
            } catch (_) {}
            return false;
        },

        // 当前 doc 内是否存在"无法访问的课程内容 iframe"（跨域 mcwk 课件）。
        // 跨域 iframe 的 contentDocument 不可读，内容只能由 iframe 内脚本实例处理；
        // 顶层实例据此静默返回，避免反复误报图文结构失败。
        hasCrossOriginCourseFrame(doc) {
            try {
                const d = doc || document;
                if (!d || typeof d.querySelectorAll !== 'function') return false;
                const iframes = d.querySelectorAll('iframe');
                for (const f of iframes) {
                    let cd = null;
                    try { cd = f.contentDocument || (f.contentWindow && f.contentWindow.document); } catch (_) {}
                    if (cd) continue; // 可访问 → 非本场景
                    const src = String((f.getAttribute && f.getAttribute('src')) || '');
                    if (/mycourse\.cn/i.test(src)) return true; // 跨域课程 iframe
                }
            } catch (_) {}
            return false;
        },

        handle(doc) {
            try {
                if (!this.isCanvasPage(doc)) return false;   // 非 Canvas 页 → 交给其它处理
                const root = this.root(doc);
                if (!root) {
                    // 动画尚未加载完成（spritesheet/manifest 加载中），等待下一轮
                    if (!this.readyLogged) {
                        this.readyLogged = true;
                        try { Logger.debug('Canvas 微课：等待动画加载完成...'); } catch (_) {}
                    }
                    return true;
                }

                // —— 结束帧：finishWxCourse() 已由动画自身触发 ——
                if (this.currentAction(root) === 'end') {
                    if (!this.doneLogged) {
                        this.doneLogged = true;
                        try { Logger.success('Canvas 微课已完成学习'); } catch (_) {}
                    }
                    // 可选：延迟后点击"返回列表"回到课程列表（CONFIG.canvasAutoBack）
                    if (!this.backClicked && CONFIG.canvasAutoBack === true) {
                        const now = Date.now();
                        if (!this.backAt) this.backAt = now;
                        if (now - this.backAt >= 2000) {
                            this.backClicked = true;
                            try {
                                if (this.fire(root, 'fanhuiliebiao')) {
                                    try { Logger.info('Canvas 微课：已点击返回列表'); } catch (_) {}
                                }
                            } catch (_) {}
                        }
                    }
                    return true;
                }

                // —— 动画播放中：等待下一个交互停止点 ——
                if (!root.paused) return true;

                // —— 停止在交互帧：按策略点击 ——
                const now = Date.now();
                if (now - this.lastClickAt < this.minClickGap) return true;
                const action = this.currentAction(root);
                if (!action) {
                    // 停止帧但无可点按钮：可能在"错误反馈/重答"帧（fan/Cuo），或过渡帧 —— 不干预
                    return true;
                }
                try {
                    if (action === 'quiz-multi') {
                        // 多选题：全选 a1-a4 后提交 → dd（正确路径）
                        for (const opt of ['a1', 'a2', 'a3', 'a4']) this.fire(root, opt);
                        if (this.fire(root, 'tijiao')) {
                            this.lastClickAt = now;
                            this.doneLogged = false;
                            try { Logger.info(`[Canvas微课] 多选答题：全选 a1-a4 并提交 (帧 ${root.currentFrame})`); } catch (_) {}
                        }
                    } else if (action === 'dui') {
                        const k = Object.keys(root).find(x => (x === 'Dui' || /^Dui\d+$/.test(x)) && this.isActive(root, x));
                        if (k && this.fire(root, k)) {
                            this.lastClickAt = now;
                            this.doneLogged = false;
                            try { Logger.info(`[Canvas微课] 判断题点"对": ${k} (帧 ${root.currentFrame})`); } catch (_) {}
                        }
                    } else if (action === 'adv') {
                        let clicked = false;
                        for (const k of ['Dian', 'xia']) {
                            if (this.isActive(root, k) && this.fire(root, k)) { clicked = true; break; }
                        }
                        if (!clicked) {
                            const kb = Object.keys(root).find(x => (x === 'nextBtn' || /^nextBtn\d+$/.test(x)) && this.isActive(root, x));
                            if (kb && this.fire(root, kb)) clicked = true;
                        }
                        if (clicked) {
                            this.lastClickAt = now;
                            this.doneLogged = false;
                            try { Logger.info(`[Canvas微课] 点击推进按钮 (帧 ${root.currentFrame})`); } catch (_) {}
                        }
                    }
                } catch (_) {}
                return true;
            } catch (e) {
                try { Logger.debug(`Canvas 微课处理异常: ${e.message}`); } catch (_) {}
                return false;
            }
        }
    };

    // ========== GraphicJsAdapter：优先使用页面原生 JS 进行图文操作 ==========
    // 依据用户提供的 item.js（典型麦课图文课件 build 产物）：
    //   · 页面全局函数：finishWxCourse() / backToList() / BtnFn(btn, from, to)
    //   · 翻页核心：$(".btn-next").click(...) → $(".page-" + sum).addClass("page-active").siblings().removeClass("page-active")
    //   · 初始化：setTimeout 2500ms 后隐藏 .loader、显示 .page-container、激活 .page-start
    //   · 结束页：.btn-next-end click → 移除 page-reciprocal 的 page-active → 激活 .page-end → setTimeout 1500ms 调用 finishWxCourse()
    //
    // 本适配器"能用原生 JS 就不用 DOM 模拟点击"，所有方法返回 { ok: boolean, reason: string }，
    // 调用方若 ok=false 则回退原有 DOM 模拟逻辑（GraphicAdapter 的三层翻页/按钮查找兜底）。
    class GraphicJsAdapter {

        // --- 环境检测 ---
        static _pageWin() {
            // 优先：递归查找承载课程内容的 iframe（可嵌套多层），返回其 contentWindow。
            try {
                const fr = GraphicJsAdapter._courseFrame();
                if (fr && fr.win) return fr.win;
            } catch (_) {}
            // 优先：直接从 iframe.page-iframe（或 src 含 mycourse/course 的课程 iframe）取
            // contentWindow。比 IframeUtils.getIframeDoc().defaultView 更稳定，避免：
            //   1) iframeDoc.defaultView 在部分文档为空（跨域/未初始化）
            //   2) getIframeDoc 返回了 document 文档本身（父级 doc）却漏掉 iframe 内全局
            // BtnFn/finishWxCourse/jQuery.$ 都是挂在 iframe.contentWindow 而非父级的，
            // 因此必须优先用 iframe.contentWindow 拿 pageWin。
            try {
                const iframe = document.querySelector('iframe.page-iframe, iframe[class*="iframe"], iframe[src*="mycourse"], iframe[src*="course"]');
                if (iframe) {
                    let cw = null;
                    try { cw = iframe.contentWindow; } catch (_) {}
                    if (cw) return cw;
                }
            } catch (_) {}
            // 次优：父级 iframe 的内容文档所在 window（学习页内容挂载在 iframe.page-iframe 内时）
            try {
                const iframeDoc = (typeof IframeUtils !== 'undefined') ? IframeUtils.getIframeDoc() : null;
                if (iframeDoc && iframeDoc.defaultView) return iframeDoc.defaultView;
            } catch (_) {}
            // 兜底：主 window（沙箱） → 页面主世界（unsafeWindow alias _skPw）
            return (typeof _skPw !== 'undefined') ? _skPw : window;
        }
        static _pageDoc() {
            // 优先：递归查找承载课程内容的 iframe（可嵌套多层），返回其内容文档。
            try {
                const fr = GraphicJsAdapter._courseFrame();
                if (fr && fr.doc && typeof fr.doc.querySelector === 'function') return fr.doc;
            } catch (_) {}
            // 同样：优先 iframe.page-iframe.contentDocument（与 _pageWin 对齐，避免 win/doc 不同源）
            try {
                const iframe = document.querySelector('iframe.page-iframe, iframe[class*="iframe"], iframe[src*="mycourse"], iframe[src*="course"]');
                if (iframe) {
                    let cd = null;
                    try { cd = iframe.contentDocument || (iframe.contentWindow && iframe.contentWindow.document); } catch (_) {}
                    if (cd && typeof cd.querySelector === 'function') return cd;
                }
            } catch (_) {}
            try {
                const iframeDoc = (typeof IframeUtils !== 'undefined') ? IframeUtils.getIframeDoc() : null;
                return iframeDoc || document;
            } catch (_) { return document; }
        }
        static _$(win) {
            const w = win || GraphicJsAdapter._pageWin();
            if (!w) return null;
            return w.$ || w.jQuery || null;
        }

        // --- 0. 页面结构容错：兼容"无 .page-item"的编号页新版模板（btn-aq-n / btn-aq-y） ---
        // 用户 JS（编号页模板）：.page-start / .page-0..N / .page-reciprocal / .page-end 直接带 .page-active，
        // 没有任何 .page-item 类。脚本其它环节硬依赖 .page-item 会导致 getDoc/开始/翻页/答题全部失效，
        // 这里统一提供"页面项列表 / 当前活跃页"的容错解析，并排除视频/布局等干扰 class。
        // 递归查找承载课程内容的 iframe（可嵌套多层，如 课程列表页 iframe → 内容页 iframe）。
        // 返回 { win, doc, sig }：sig 用于说明命中信号；找不到返回 null。
        static _findCourseFrame(rootDoc, depth, visited) {
            if (depth > 5) return null;
            let iframes = [];
            try { iframes = Array.from(rootDoc.querySelectorAll('iframe')); } catch (_) {}
            for (const f of iframes) {
                let cw = null, cd = null;
                try { cw = f.contentWindow; } catch (_) {}
                try { cd = f.contentDocument || (cw && cw.document); } catch (_) {}
                if (!cd) continue;
                let sig = 0;
                try {
                    if (cd.querySelector('.page-item, .page-slide, .page-start, .btn-start, .loader, .page-reciprocal, .page-end, [class*="page-container"]')) sig = 1;
                } catch (_) {}
                try {
                    if (!sig && cd.querySelectorAll('[class^="page-"]').length >= 2) sig = 2;
                } catch (_) {}
                if (sig) return { win: cw, doc: cd, sig };
                const nested = GraphicJsAdapter._findCourseFrame(cd, depth + 1, visited);
                if (nested) return nested;
            }
            return null;
        }
        static _courseFrame() {
            try { return GraphicJsAdapter._findCourseFrame(document, 0, []); } catch (_) { return null; }
        }
        static pageItems(doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            if (!d || typeof d.querySelectorAll !== 'function') return [];
            let els = [];
            try { els = Array.from(d.querySelectorAll('.page-item')); } catch (_) {}
            if (!els.length) {
                // 编号页模板无 .page-item：收集所有含 page- 前缀 token 的元素，JS 过滤掉视频/布局等干扰类。
                // 用 [class*="page-"] + 正则 token 过滤，避免依赖 :not()/[class^=] 这类伪类与属性选择器（部分环境/测试 mock 不支持）。
                try {
                    els = Array.from(d.querySelectorAll('[class*="page-"]')).filter((el) => {
                        let c = '';
                        try { c = String(el.className != null ? el.className : ''); } catch (_) {}
                        if (!c) { try { c = String(el.getAttribute ? el.getAttribute('class') || '' : ''); } catch (_) {} }
                        if (!c) return false;
                        if (!/(^|\s)page-/.test(c)) return false;
                        return !/(^|\s)(page-video|page-wh|page-header|page-footer|page-wrapper|page-container|page-iframe|page-slide|page-graphic|page-area|page-content|page-box)(\s|$)/.test(c);
                    });
                } catch (_) {}
            }
            return els;
        }
        static activePage(doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const els = GraphicJsAdapter.pageItems(d);
            // 优先返回非 page-start 的活跃页：站点 2500ms 定时器可能在课程已开始后
            // 给 .page-start 重复加 page-active（双活跃页），此时若返回 page-start 会被误判回起始页。
            // 仅当没有其它活跃页时才返回 page-start（即课程尚未开始的正常初始态）。
            let startActive = null;
            for (const el of els) {
                try {
                    if (el.classList && el.classList.contains('page-active')) {
                        if (el.classList.contains('page-start')) { if (!startActive) startActive = el; continue; }
                        return el;
                    }
                } catch (_) {}
            }
            if (startActive) return startActive;
            try { const a = d.querySelector('.page-active'); if (a) return a; } catch (_) {}
            return null;
        }
        // 诊断：输出当前文档/页面结构的紧凑 JSON，用于"暂无法 JS 触发开始"等失败分支定位根因
        static diagPageStructure(doc, tag) {
            try {
                const d = doc || GraphicJsAdapter._pageDoc();
                if (!d || typeof d.querySelectorAll !== 'function') return;
                const num = (sel) => { try { return d.querySelectorAll(sel).length; } catch (_) { return -1; } };
                const act = GraphicJsAdapter.activePage(d);
                // ---- iframe 诊断：内容可能挂在（嵌套）iframe 内 ----
                let frameInfos = [];
                try {
                    const scanFrames = (rootDoc, depth) => {
                        if (depth > 3 || frameInfos.length >= 6) return;
                        let iframes = [];
                        try { iframes = Array.from(rootDoc.querySelectorAll('iframe')); } catch (_) { return; }
                        for (const f of iframes) {
                            let cw = null, cd = null;
                            try { cw = f.contentWindow; } catch (_) {}
                            try { cd = f.contentDocument || (cw && cw.document); } catch (_) {}
                            const src = String(f.getAttribute ? (f.getAttribute('src') || '') : '').slice(0, 48);
                            const info = { d: depth, src: src, acc: !!cd };
                            if (cd) {
                                try { info.st = !!cd.querySelector('.page-start'); } catch (_) {}
                                try { info.btn = !!cd.querySelector('.btn-start'); } catch (_) {}
                                try { info.n = cd.querySelectorAll('[class^="page-"]').length; } catch (_) {}
                                try { info.pi = cd.querySelectorAll('.page-item, .page-slide').length; } catch (_) {}
                                try { info.active = !!cd.querySelector('.page-active'); } catch (_) {}
                            }
                            frameInfos.push(info);
                            if (cd) scanFrames(cd, depth + 1);
                        }
                    };
                    scanFrames(typeof document !== 'undefined' ? document : d, 0);
                } catch (_) {}
                let courseFrameHit = false, pageWinIsTop = true, winHasBtn = false;
                try { courseFrameHit = !!GraphicJsAdapter._courseFrame(); } catch (_) {}
                try { const pw = GraphicJsAdapter._pageWin(); pageWinIsTop = (pw === (typeof window !== 'undefined' ? window : null)); winHasBtn = !!(pw && (pw.BtnFn || pw.finishWxCourse || pw.backToList)); } catch (_) {}
                const inf = {
                    docIsTop: d === (typeof document !== 'undefined' ? document : null),
                    pageItem: num('.page-item'),
                    pageStart: num('.page-start'),
                    pageContainer: num('.page-container'),
                    pageReciprocal: num('.page-reciprocal'),
                    pageEnd: num('.page-end'),
                    numbered: num('[class^="page-"]'),
                    pageActive: num('.page-active'),
                    btnStart: num('.btn-start'),
                    activeCls: act ? String(act.className || '') : null,
                    activeTag: act ? String(act.tagName || act._tag || '') : null,
                    activeId: (act && typeof act.getAttribute === 'function') ? (act.getAttribute('id') || '') : '',
                    topFrames: (() => { try { return Array.from(document.querySelectorAll('iframe')).length; } catch (_) { return -1; } })(),
                    frames: frameInfos,
                    courseFrameHit: courseFrameHit,
                    pageWinIsTop: pageWinIsTop,
                    winHasBtn: winHasBtn
                };
                try { Logger.info('[图文结构诊断' + (tag ? ':' + tag : '') + '] ' + JSON.stringify(inf)); } catch (_) {
                    try { (globalThis || window).__scDiag = inf; } catch (_2) {}
                }
            } catch (_) {}
        }

        /**
         * 完成链路加固（幂等，可在主循环反复调用）：
         * 1) hook 站点 window.alert —— 拦截"发送完成失败"弹窗并记录诊断（iframe/top 的 userCourseId、href）。
         * 2) hook 站点 finishWxCourse —— 诊断 + 若 iframe URL 缺 userCourseId 而 top 有，则改用脚本
         *    _finishSDK（_qs 读 top 参数，URL 完整）完成，避免 v2/undefined.do JSONP 404 → 弹"发送完成失败"。
         * 站点 sdk.js 的 queryString 只读 iframe 自己 location.search，userCourseId 常只在 top 地址栏，
         * 因此必须在此补齐。仅包装"真实站点 finishWxCourse"（脚本 no-op 占位不包装，保持 avoidDirectFinish 语义）。
         */
        static _ensureFinishHook(doc, win) {
            try {
                const w = win || GraphicJsAdapter._pageWin() || (typeof window !== 'undefined' ? window : null);
                const d = doc || GraphicJsAdapter._pageDoc();
                if (!w) return;
                const _iq = (n) => { try { return new URLSearchParams(String(w.location.search || '')).get(n); } catch (_) { return null; } };
                const _tq = (n) => { try { return new URLSearchParams(String((w.top && w.top.location && w.top.location.search) || '')).get(n); } catch (_) { return null; } };
                // (a) alert 拦截（幂等）
                if (w && typeof w.alert === 'function' && !w.__skFinishAlertHooked) {
                    try {
                        const _oa = w.alert;
                        w.__skFinishAlertHooked = true;
                        w.alert = function (_msg) {
                            try {
                                const _s = String(_msg || '');
                                if (_s.indexOf('发送完成失败') >= 0) {
                                    let _diag = '';
                                    try {
                                        _diag = 'iframe.userCourseId=' + (_iq('userCourseId') || '空')
                                            + ' top.userCourseId=' + (_tq('userCourseId') || '空')
                                            + ' weiban=' + (_iq('weiban') || '空') + ' lyra=' + (_iq('lyra') || '空')
                                            + ' source=' + (_iq('source') || '空') + ' href=' + String(w.location.href || '').slice(0, 160);
                                    } catch (_) {}
                                    try { Logger.warn('[完成] 拦截"发送完成失败"弹窗。诊断: ' + _diag); } catch (_) {}
                                    try { State._finishFailDiag = { msg: _s, diag: _diag, ts: Date.now() }; } catch (_) {}
                                    return; // 不弹窗
                                }
                            } catch (_) {}
                            try { return _oa.apply(this, arguments); } catch (_) {}
                        };
                    } catch (_) {}
                }
                // (b) finishWxCourse hook（幂等；仅包装真实站点实现，跳过脚本 no-op 占位）
                if (w && typeof w.finishWxCourse === 'function' && !w.__skFinishHooked) {
                    try {
                        const _origFinish = w.finishWxCourse;
                        const _isPlaceholder = /no-op（avoidDirectFinish|no-op\s*\(avoidDirectFinish/.test(String(_origFinish));
                        if (!_isPlaceholder) {
                            w.__skFinishHooked = true;
                            w.finishWxCourse = function () {
                                let _r;
                                try {
                                    const _ifu = _iq('userCourseId');
                                    const _topu = _tq('userCourseId');
                                    try { Logger.info('[完成] finishWxCourse 触发 iframe.userCourseId=' + (_ifu || '空') + ' top.userCourseId=' + (_topu || '空') + ' weiban=' + (_iq('weiban') || '空') + ' lyra=' + (_iq('lyra') || '空') + ' source=' + (_iq('source') || '空')); } catch (_) {}
                                    // iframe 缺 userCourseId 但 top 有 → 站点 sdk finish 必然 v2/undefined.do 失败，
                                    // 改用脚本 _finishSDK（_qs 读 top，URL 完整）
                                    if (!_ifu && _topu) {
                                        try { Logger.warn('[完成] iframe 缺 userCourseId（top 有），改用脚本 SDK（top 参数）完成'); } catch (_) {}
                                        try { GraphicJsAdapter._finishSDK(d, w); } catch (_) {}
                                        // 【刷课上报】图文完成路径补 completed（v1.2 刷课统计；report 内部防重）
                                        try { if (typeof StudyReporter !== 'undefined') StudyReporter.report('completed'); } catch (_) {}
                                        return;
                                    }
                                } catch (_) {}
                                try { _r = _origFinish.apply(this, arguments); } catch (_) {}
                                // 【刷课上报】图文完成（finishWxCourse 链路）补上报 completed，防重仅在成功后置位、失败下次重试
                                try { if (typeof StudyReporter !== 'undefined') StudyReporter.report('completed'); } catch (_) {}
                                return _r;
                            };
                        }
                    } catch (_) {}
                }
            } catch (_) {}
        }

        /**
         * 当前页面是否暴露了图文原生 JS 环境（至少具备 finishWxCourse / backToList / jQuery.$ 其一）
         */
        static hasNativeSupport() {
            try {
                const w = GraphicJsAdapter._pageWin();
                const d = GraphicJsAdapter._pageDoc();
                if (!w) return false;
                const $ = GraphicJsAdapter._$(w);
                const native = !!(w.finishWxCourse || w.backToList || w.BtnFn || $);
                // sdk.js 对齐：首次命中（native=true 或 页面有 d.body/page-item）时安装环境，
                // 即使没有 sdk.js 注入，也能把 finishWxCourse / backToList / hideOptionMenu / wx.miniProgram 覆盖 / dufe postMessage 补上。
                try { GraphicJsAdapter._installSDKEnv(d, w); } catch (_) {}
                // 完成链路加固（幂等）：hook finishWxCourse 补 userCourseId + 拦截"发送完成失败"弹窗
                try { GraphicJsAdapter._ensureFinishHook(d, w); } catch (_) {}
                return native;
            } catch (_) { return false; }
        }

        // --- 0-bis. 通用工具：pxToRem / setWidth（与用户新版 item.js 完全一致） ---
        // 用户 JS：
        //   function pxToRem(px) { a = px / 100; b = a + 'rem'; return b; }
        //   function setWidth(page) {
        //     $(page).find('.element').each(function() {
        //       let nw = $(this)[0].naturalWidth;
        //       if (nw) $(this).css('width', pxToRem(nw));
        //       else { let nImg = new Image(); nImg.src = $(this)[0].src; w = nImg.width;
        //              if(!w) return console.log(...);
        //              $(this).css('width', pxToRem(w)); console.log("不支持naturalWidth，但支持new Image()")
        //       }
        //     });
        //   }
        // 优先调用页面全局 setWidth/pxToRem（站点自己的实现、可能带缓存/兼容），
        // 拿不到时在本地按等价逻辑跑一遍，确保图文页图片在没有站点 observer 时也能正确设宽。
        static pxToRem(px) {
            if (!Number.isFinite(px)) return null;
            try {
                const w = GraphicJsAdapter._pageWin();
                if (w && typeof w.pxToRem === 'function') {
                    try { const r = w.pxToRem(px); if (typeof r === 'string' && r) return r; } catch (_) {}
                }
            } catch (_) {}
            return (Number(px) / 100) + 'rem';
        }
        static setWidth(pageSelectorOrEl, doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            if (!d || typeof d.querySelectorAll !== 'function') return { ok: false, reason: 'no-doc' };
            // 1) 优先全局 setWidth（站点实现、带 naturalWidth / new Image 双通路）
            let globalRan = false;
            try {
                if (w && typeof w.setWidth === 'function') {
                    const sel = (typeof pageSelectorOrEl === 'string') ? pageSelectorOrEl : (pageSelectorOrEl && ('#' + (pageSelectorOrEl.id || '')));
                    try { w.setWidth(sel || '.page-start'); globalRan = true; } catch (_) { globalRan = false; }
                }
            } catch (_) { globalRan = false; }
            // 2) 本地等价 setWidth：在指定容器内找到 .element（一般是图片）并按宽度计算 rem
            let localCount = 0;
            try {
                const root = (typeof pageSelectorOrEl === 'string')
                    ? (d.querySelector(pageSelectorOrEl) || d.body || d)
                    : (pageSelectorOrEl || d.body || d);
                if (root && typeof root.querySelectorAll === 'function') {
                    const imgs = Array.from(root.querySelectorAll('img.element, .element img, img[class*="element"], .page-slide img, .item img'));
                    const $$ = GraphicJsAdapter._$(w);
                    for (const img of imgs) {
                        if (!img || img.nodeType !== 1) continue;
                        let width = null;
                        try {
                            if (typeof img.naturalWidth === 'number' && img.naturalWidth > 0) {
                                width = img.naturalWidth;
                            }
                        } catch (_) {}
                        if (!width && typeof Image !== 'undefined') {
                            try {
                                const src = img.getAttribute && img.getAttribute('src');
                                if (src) {
                                    try {
                                        const nImg = new Image();
                                        nImg.src = src;
                                        if (typeof nImg.width === 'number' && nImg.width > 0) width = nImg.width;
                                    } catch (_) {}
                                }
                            } catch (_) {}
                        }
                        if (!width) continue;
                        const rem = GraphicJsAdapter.pxToRem(width);
                        if (!rem) continue;
                        try { img.style.width = rem; localCount++; } catch (_) {}
                        try { if ($$ && typeof $$ === 'function') { $$(img).css && $$(img).css('width', rem); } } catch (_) {}
                    }
                }
            } catch (_) {}
            return { ok: globalRan || localCount > 0, reason: globalRan ? 'global-setWidth' : ('local-setWidth-' + localCount), count: localCount };
        }

        // --- 0-ter. Pbgfn 背景音渐隐（等价用户新版：volume 每 400ms -0.1 直到 0，最后 clickPbg.pause + 隐藏播放/暂停图标）---
        static Pbgfn(doc) {
            const w = GraphicJsAdapter._pageWin();
            const d = doc || GraphicJsAdapter._pageDoc();
            // 优先调用页面全局 Pbgfn（它自己维护 clickPbg/audioPlay/audioPause 引用）
            try {
                if (w && typeof w.Pbgfn === 'function') { try { w.Pbgfn(); return { ok: true, reason: 'global-Pbgfn' }; } catch (_) {} }
            } catch (_) {}
            // 兜底：按 400ms 间隔把 clickPbg 音量从当前值降到 0
            try {
                const clickPbg = (w && w.clickPbg) || (d && d.getElementById && d.getElementById('click-Pbg'));
                const audioPause = (w && w.audioPause) || (d && d.querySelector && d.querySelector('.icon-audio-close'));
                const audioPlay = (w && w.audioPlay) || (d && d.querySelector && d.querySelector('.icon-audio-play'));
                if (!clickPbg) return { ok: false, reason: 'no-click-Pbg' };
                let volume = typeof clickPbg.volume === 'number' ? clickPbg.volume : 0.4;
                if (typeof clickPbg.volume !== 'number') return { ok: false, reason: 'no-volume-prop' };
                if (typeof w !== 'undefined' && typeof w.setInterval === 'function') {
                    const itv = w.setInterval(() => {
                        try {
                            volume -= 0.1;
                            if (volume <= 0) {
                                volume = 0;
                                w.clearInterval(itv);
                                try { clickPbg.pause && clickPbg.pause(); } catch (_) {}
                                try { if (audioPause && audioPause.style) audioPause.style.display = 'none'; } catch (_) {}
                                try { if (audioPlay && audioPlay.style) audioPlay.style.display = 'none'; } catch (_) {}
                            }
                            clickPbg.volume = Math.max(0, volume);
                        } catch (_) { try { w.clearInterval(itv); } catch (_) {} }
                    }, 400);
                    return { ok: true, reason: 'local-Pbgfn' };
                }
                // 非浏览器环境：直接手动归 0
                try { clickPbg.volume = 0; if (typeof clickPbg.pause === 'function') clickPbg.pause(); } catch (_) {}
                return { ok: true, reason: 'local-Pbgfn-sync' };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 0-quater. 安装 MutationObserver：与用户新版等价，监听 .page-container 属性/子树变化，
        // 对当前 active page-item 及其 next/prev 自动调 setWidth，避免手动切 class 后图片仍为零宽。
        static _installedObserverKey = null;
        static installWidthObserver(doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            if (!d || !w) return { ok: false, reason: 'no-env' };
            if (GraphicJsAdapter._installedObserverKey) return { ok: true, reason: 'already-installed' };
            try {
                const container = d.querySelector('.page-container');
                if (!container) return { ok: false, reason: 'no-page-container' };
                if (typeof w.MutationObserver !== 'function') return { ok: false, reason: 'no-MutationObserver' };
                const callback = () => {
                    try {
                        const actives = d.querySelectorAll('.page-active');
                        actives.forEach(el => {
                            GraphicJsAdapter.setWidth(el, d);
                            GraphicJsAdapter.setWidth(el.nextElementSibling || el, d);
                            GraphicJsAdapter.setWidth(el.previousElementSibling || el, d);
                        });
                    } catch (_) {}
                };
                const ob = new w.MutationObserver(callback);
                ob.observe(container, { attributes: true, subtree: true });
                GraphicJsAdapter._installedObserverKey = ob;
                // 首次回调：对当前 active 先立即跑一次 setWidth，补齐 setTimeout 1500 那条 setWidth('.page-start')
                try { callback(); } catch (_) {}
                return { ok: true, reason: 'observer-installed' };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 1. Loader 初始化（用户新版是双 setTimeout：1500ms setWidth('.page-start')；2500ms 隐藏 loader、显示容器、激活 page-start）---
        // 这里做"同步等价"：直接完成这两步，不等待 1500/2500ms。
        //   1) setWidth('.page-start')
        //   2) .loader display:none / .page-container display:block / .page-start.page-active（仅当无其它 active page 时）
        // 额外：顺便安装一次 setWidth MutationObserver（若还没装）。
        static clearLoader(doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            if (!d || typeof d.querySelector !== 'function') return { ok: false, reason: 'no-doc' };
            try {
                // 用户新版第一步：1500ms → setWidth('.page-start')
                let step1Ok = false;
                try {
                    const sw = GraphicJsAdapter.setWidth('.page-start', d);
                    step1Ok = !!sw.ok;
                } catch (_) {}
                // 安装 MutationObserver（与用户新版 $(document).ready 内的 observer 等价）
                let obInfo = null;
                try { obInfo = GraphicJsAdapter.installWidthObserver(d); } catch (_) {}

                // 用户新版第二步：2500ms → 隐藏 loader、显示容器、激活 page-start
                let step2Changed = false;
                const loader = d.querySelector('.loader');
                if (loader && loader.style && loader.style.display !== 'none') {
                    try { loader.style.display = 'none'; step2Changed = true; } catch (_) {}
                }
                const container = d.querySelector('.page-container');
                if (container && container.style && container.style.display !== 'block') {
                    try { container.style.display = 'block'; step2Changed = true; } catch (_) {}
                }
                const hasAnyActivePage = !!d.querySelector('.page-active');
                const pageStart = d.querySelector('.page-start');
                if (!hasAnyActivePage && pageStart && !pageStart.classList.contains('page-active')) {
                    try { pageStart.classList.add('page-active'); step2Changed = true; } catch (_) {}
                }
                const changed = step1Ok || step2Changed;
                return {
                    ok: changed,
                    reason: changed ? 'loader-skipped-2500' : 'already-done',
                    setWidth: step1Ok,
                    observer: obInfo ? obInfo.reason : null
                };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 2. 开始学习 / 回到起始页：优先触发站点 .btn-start / .btn-prev-start 的 click handler ---
        // 用户 JS：
        //   function BtnFn(Btn, PageStart, PageEnd) {
        //     document.querySelector(Btn).addEventListener("click", function() {
        //       document.querySelector(PageStart).classList.remove("page-active");
        //       document.querySelector(PageEnd).classList.add("page-active");
        //     });
        //   }
        //   BtnFn(".btn-start", ".page-start", ".page-0");
        //   BtnFn(".btn-prev-start", ".page-0", ".page-start");
        // 由于 BtnFn 内部只注册 addEventListener('click' …)，不提供"同步调用"的公共 API，
        // 正确做法是按优先级：
        //   1) jQuery.trigger('click') + 原生 .click() + new MouseEvent('click') dispatchEvent
        //      → 三套一起上，确保 jQuery/原生 addEventListener 都命中。
        //   2) 若找不到按钮或按钮不可点击，再直接调用全局 w.BtnFn（仅当站点 BtnFn 幂等时安全）。
        //   3) 兜底手动 class 切换。
        // 另外：根据当前 active 所在位置智能选择 START 方向或 PREV-START 反向：
        //   · page-start 激活  → 前进 .btn-start
        //   · page-0 激活      → 反向 .btn-prev-start（退回起始页，用于答题失败时站点重置）
        static startCourse(doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            if (!d) return { ok: false, reason: 'no-doc' };
            try {
                // 用户新版 BtnFn(".btn-start", …) 会在 click 后 600ms 调用 Hlsplay('mse', CDN)
                // 启动 Hls 视频播放器（图文内嵌视频，page-0 内 id='mse' 的播放器容器）。
                // 由于 Hlsplay/Player/CDN 只在站点闭合作用域里，我们只能：
                //   1) 若能拿到页面全局 Hlsplay → 直接按用户参数 (id='mse', 从 page-0 data-src / script 文本取 CDN)
                //   2) 若页面把全局 Hlsplay 暴露到 window 上 → setTimeout 600ms 调一次兜底
                //   3) 取不到时不阻塞：只返回 startCourse 切页成功（Controller 之后 handleEmbeddedVideo 会接管 page-0 的 video）
                const scheduleHlsplay = (extraReason) => {
                    try {
                        if (!w || typeof w.setTimeout !== 'function') return;
                        w.setTimeout(() => {
                            try {
                                if (typeof w.Hlsplay === 'function') {
                                    // 尝试从 page-0 > #mse.dataset.src / data-cdn 取真实 CDN，拿不到就用占位（会被站点自己的 handler 覆盖）
                                    let cdn = '';
                                    try {
                                        const mse = d.getElementById && d.getElementById('mse');
                                        if (mse) {
                                            cdn = (mse.getAttribute && (mse.getAttribute('data-src') || mse.getAttribute('data-cdn'))) || '';
                                        }
                                    } catch (_) {}
                                    if (!cdn) {
                                        // 兜底：若 page-0 内嵌的 <source> 或 <script> 里可扫到 mp4 链接，就取第一个
                                        try {
                                            const page0 = d.querySelector('.page-0, [class*="page-0"]');
                                            if (page0) {
                                                const src = page0.innerHTML.match(/https?:\/\/[^"'`\s)]+\.mp4[^"'`\s)]*/);
                                                if (src && src[0]) cdn = src[0];
                                            }
                                        } catch (_) {}
                                    }
                                    if (cdn) {
                                        try { w.Hlsplay('mse', cdn); extraReason.push('Hlsplay-cdn'); } catch (_) { extraReason.push('Hlsplay-err'); }
                                    } else {
                                        // 不传 CDN：若站点 Hlsplay 支持容错就直接跑，否则静默失败
                                        try { w.Hlsplay('mse', ''); extraReason.push('Hlsplay-empty'); } catch (_) { extraReason.push('Hlsplay-err'); }
                                    }
                                }
                            } catch (_) { /* 静默：Hlsplay 失败不影响切页流程 */ }
                        }, 600);
                    } catch (_) {}
                };

                // 判定方向：前向 btn-start 还是 反向 btn-prev-start
                const active = GraphicJsAdapter.activePage(d);
                const activeClass = active ? (active.className || '') : '';
                // 方向策略：
                //   若当前活跃项包含 .page-0（且不包含 .page-start）→ 视为需要反向回到起始
                //   其它（包括无 active、active 在 start、或 active 在 page-N 其它页）→ 按默认 START 方向
                const isPage0Only = /(^|\s)page-0(\s|$)/.test(activeClass) && !/(^|\s)page-start(\s|$)/.test(activeClass);
                const direction = isPage0Only ? 'prev' : 'next';
                try { (globalThis || window).__scDir = { activeClass: activeClass, isPage0Only: isPage0Only, direction: direction, activeTag: active && active._tag }; } catch (_) {}
                const btnSelector = (direction === 'prev')
                    ? '.btn-prev-start, [class*="btn-prev-start"], a.btn-prev-start'
                    : '.btn-start, [class*="btn-start"][class*="an-position"], a.btn-start';
                const fromSel = (direction === 'prev') ? '.page-0' : '.page-start';
                const toSel = (direction === 'prev') ? '.page-start' : '.page-0';

                const $ = GraphicJsAdapter._$(w);
                // 2a. 首选：jQuery trigger + 原生 click + dispatchEvent(MouseEvent)
                const _dispatchClick = (btnEl) => {
                    if (!btnEl) return false;
                    let any = false;
                    try {
                        if (typeof btnEl.click === 'function') { btnEl.click(); any = true; }
                    } catch (_) {}
                    try {
                        if (typeof btnEl.dispatchEvent === 'function' && typeof Event !== 'undefined') {
                            // 新版 BtnFn 是 addEventListener('click',…)，MouseEvent 明确 click 能确保进入。
                            const evt = (typeof MouseEvent === 'function')
                                ? new MouseEvent('click', { bubbles: true, cancelable: true, view: (w && typeof w.window !== 'undefined') ? w.window : null })
                                : document.createEvent('MouseEvents');
                            if (evt && typeof evt.initMouseEvent === 'function' && typeof MouseEvent !== 'function') {
                                evt.initMouseEvent('click', true, true, (w || window), 1, 0, 0, 0, 0, false, false, false, false, 0, null);
                            }
                            btnEl.dispatchEvent(evt);
                            any = true;
                        }
                    } catch (_) {}
                    return any;
                };
                try {
                    // 方向检测 & 按钮/切换对象日志（仅在有 Logger 时写 debug，避免测试环境报错）
                    try { if (typeof Logger !== 'undefined' && Logger.debug) Logger.debug('[startCourse] direction=' + direction + ' btnSel=' + btnSelector + ' hasBtn=' + !!(d.querySelector(btnSelector))); } catch (_) {}
                } catch (_) {}

                // 工具：判断 fromSel → toSel 的切换是否真的完成了
                const hasSwitched = () => {
                    try {
                        const fromEl = d.querySelector(fromSel);
                        const toEl = d.querySelector(toSel) || d.querySelector('[class*="' + toSel.replace(/^\./, '') + '"]');
                        if (toEl && toEl.classList && toEl.classList.contains('page-active')) return true;
                        if (fromEl && fromEl.classList && !fromEl.classList.contains('page-active') && toEl) return true;
                    } catch (_) {}
                    return false;
                };
                const extraHls = [];
                let btnTriggered = false;
                let btnReasonBase = null;
                if ($ && typeof $ === 'function') {
                    try {
                        // 优先在 active 页内查找按钮：避免多个 .btn-start / .btn-prev-start 同时存在（如
                        // 起始页上一个按钮、page-0 上一个反向按钮）时误点到非当前页按钮上，导致 click
                        // listener 因为不是我们挂监听器的那颗 btn 从而完全不切页。
                        const btnBase = (active && active.querySelectorAll) ? active : d;
                        const $btn = $(btnBase).find ? $(btnBase).find(btnSelector) : $(btnSelector);
                        if ($btn && $btn.length) {
                            $btn.trigger('click');
                            try { _dispatchClick($btn[0]); } catch (_) {}
                            btnTriggered = true;
                            btnReasonBase = (direction === 'prev' ? 'jQuery-btn-prev-start-trigger' : 'jQuery-btn-start-trigger');
                        }
                    } catch (_) {}
                }
                if (!btnTriggered) {
                    try {
                        const btnBase = (active && active.querySelector) ? active : d;
                        const btnEl = btnBase.querySelector(btnSelector) || d.querySelector(btnSelector);
                        if (btnEl) {
                            _dispatchClick(btnEl);
                            btnTriggered = true;
                            btnReasonBase = (direction === 'prev' ? 'native-btn-prev-start-click' : 'native-btn-start-click');
                        }
                    } catch (_) {}
                }
                // 关键：按钮 trigger 仅作为"尝试"，不直接返回。只有真的切页才把触发原因当成功；
                // 否则继续走 BtnFn / manual / jQuery.next 多条兜底（否则 mock / 无监听环境死路）。
                if (btnTriggered && hasSwitched()) {
                    if (direction === 'next') scheduleHlsplay(extraHls);
                    return { ok: true, reason: btnReasonBase + (extraHls.length ? ('+' + extraHls.join('+')) : '') };
                }

                // 2b. 兜底：全局 BtnFn（若存在则直接 BtnFn(btnSel, fromSel, toSel)）——
                //     注意：用户新版 BtnFn 每次调用会重复 addEventListener，不宜多次调用。
                //     仅在"确定站点还没注册过或注册不影响切页"时用。此处作为最后兜底。
                if (w && typeof w.BtnFn === 'function') {
                    try {
                        // 2b-1：先尝试手动 class 切换，再用 BtnFn（BTN 注册后 click 切逻辑与 manual 等价，
                        // 这里直接手动切一次更安全，因为 BtnFn 本身不"立刻切"，只绑 click）。
                        const fromEl = d.querySelector(fromSel);
                        const toEl = d.querySelector(toSel);
                        if (fromEl && fromEl.classList.contains('page-active') && toEl) {
                            try { fromEl.classList.remove('page-active'); toEl.classList.add('page-active'); } catch (_) {}
                            const extra = [];
                            if (direction === 'next') scheduleHlsplay(extra);
                            return { ok: true, reason: (direction === 'prev' ? 'prevstart-manual-class' : 'btnstart-manual-class') + (extra.length ? ('+' + extra.join('+')) : '') };
                        }
                        // 2b-2：实在找不到 from/to，调用一次 BtnFn（依赖站点内部实现）
                        try {
                            w.BtnFn(btnSelector.split(',')[0].trim(), fromSel, toSel);
                            const extra = [];
                            if (direction === 'next') scheduleHlsplay(extra);
                            return { ok: true, reason: 'BtnFn-called' + (extra.length ? ('+' + extra.join('+')) : '') };
                        } catch (_) {}
                    } catch (_) {}
                }

                // 2c. 兜底 class 切换（优先精确 toSel，次选 [class*="xxx"] 属性兜底）
                {
                    const fromEl = d.querySelector(fromSel);
                    let toEl = d.querySelector(toSel);
                    if (!toEl) {
                        const clsName = toSel.replace(/^\./, '');
                        toEl = d.querySelector('[class*="' + clsName + '"]');
                    }
                    try {
                        if (typeof Logger !== 'undefined' && Logger.debug) {
                            Logger.debug('[startCourse-2c] direction=' + direction + ' from=' + !!fromEl + ' fromActive=' + !!(fromEl && fromEl.classList && fromEl.classList.contains('page-active')) + ' to=' + !!toEl);
                        }
                    } catch (_) {}
                    try {
                        (globalThis || window).__sc2c = {
                            direction: direction, fromSel: fromSel, toSel: toSel,
                            fromElExists: !!fromEl,
                            toElExists: !!toEl,
                            fromActive: !!(fromEl && fromEl.classList && fromEl.classList.contains('page-active')),
                            finalCondition: !!(fromEl && fromEl.classList && fromEl.classList.contains('page-active') && toEl),
                        };
                    } catch (_) {}
                    if (fromEl && fromEl.classList.contains('page-active') && toEl) {
                        try { fromEl.classList.remove('page-active'); toEl.classList.add('page-active'); } catch (_) {}
                        const extra = [];
                        if (direction === 'next') scheduleHlsplay(extra);
                        return { ok: true, reason: 'class-switch-' + direction + (extra.length ? ('+' + extra.join('+')) : '') };
                    }
                }

                // 2d. jQuery.next 宽兜底（仅 next 方向）
                if (direction === 'next' && $ && typeof $ === 'function') {
                    const $start = $('.page-start');
                    if ($start && $start.length && $start.hasClass && $start.hasClass('page-active')) {
                        const $next = $start.next();
                        if ($next && $next.length) {
                            try {
                                $start.removeClass('page-active');
                                $next.addClass('page-active');
                                const extra = [];
                                scheduleHlsplay(extra);
                                return { ok: true, reason: 'jQuery-next' + (extra.length ? ('+' + extra.join('+')) : '') };
                            } catch (_) {}
                        }
                    }
                }

                try { (globalThis || window).__scFinal = { direction, fromSel, toSel, d_hasFrom: !!d.querySelector(fromSel), d_hasTo: !!d.querySelector(toSel), fromHasActive: !!(d.querySelector(fromSel) && d.querySelector(fromSel).classList.contains('page-active')) }; } catch (_) {}
                return { ok: false, reason: 'no-start-pair' };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 3. 翻页：对齐用户新版 $(".btn-next").each handler 的完整行为 ---
        // 用户新版 JS（不仅翻页，还有音效 / P2&P3 联动）：
        //   $(".btn-next").each(function(index) {
        //     $(this).click(function() {
        //       sum = index + 1;
        //       if($(this).hasClass("p0102")) { clickStart.play(); clickPbg.play(); }
        //       else { clickBase.play(); }
        //       $(this).parents(".page-item").next(".page-item")
        //              .addClass("page-active").siblings().removeClass("page-active");
        //       if($(".page-3").hasClass("page-active")) {
        //         setTimeout(() => clickP3.play(), 500);
        //         clickP2.pause(); clickP2.currentTime = 0;
        //       }
        //     });
        //   });
        // 注意：
        //   · 翻页用 jQuery 的 parents(".page-item").next(".page-item")，而不是数组顺序 +1，
        //     这样对 DOM 结构（非 page-N 数字类名的变体）更稳。
        //   · 音效 play() 在浏览器端可能因没有用户手势抛错，直接 try/catch 吞掉；离线环境不存在也跳过。
        //   · p0102 特殊按钮：需要同步播 clickStart + clickPbg（一般是 page-start → page-1 时的特殊音效 + 背景音乐开启）。
        //   · 若下一页是 .page-aqNN / .page-afNN / .page-atNN：保留旧逻辑不切，交给答题链路。
        static advancePage(doc, allowStart) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            if (!d || typeof d.querySelectorAll !== 'function') return { ok: false, reason: 'no-doc' };
            try {
                const sections = GraphicJsAdapter.pageItems(d);
                if (!sections.length) return { ok: false, reason: 'no-page-item' };
                const curSection = GraphicJsAdapter.activePage(d);
                if (!curSection) return { ok: false, reason: 'no-active-page' };
                const currentIndex = sections.indexOf(curSection);
                // 起始页 → 需显式 allowStart=true（与 forceAdvancePage 语义一致）
                if (curSection.classList.contains('page-start') && !allowStart) {
                    return { ok: false, reason: 'page-start-blocked' };
                }
                const $ = GraphicJsAdapter._$(w);
                // Step 0：优先找当前 active 内的 .btn-next；若命中则直接 trigger('click')，
                // 此时站点已经挂好 click handler，音效/翻页/p2p3 全在用户 JS 闭包里完成，
                // 我们只负责"成功触达 handler"这一件事。
                let btnTriggered = false;
                let btnInActive = null;
                try {
                    if (curSection && typeof curSection.querySelector === 'function') {
                        // 【中枢模板兼容】排除编号叠加层（btn-next26 / btn-prev26 等）：它们是"跳回 page-26
                        // 中枢"的导航按钮（站点 $(".btn-next26,.btn-prev26").click → $(".page-26").addClass），
                        // 不是线性下一页。模糊匹配 [class*="btn-next"] 会把它们当 next 点击 → 跳回中枢 →
                        // DOM-next 重进辐条页 → 8↔12 死循环。与 isUsableNext 的 /btn·?next\d|next·?btn\d/ 同一过滤。
                        const btnCands = curSection.querySelectorAll('.btn-next, [class*="btn-next"]');
                        for (const cand of btnCands) {
                            const cls = ((cand.className || '') + ' ' + ((cand.getAttribute && cand.getAttribute('class')) || ''));
                            const norm = cls.replace(/([a-z0-9])([A-Z])/g, '$1·$2').toLowerCase().replace(/[-_\s]+/g, '·');
                            if (/btn·?next\d|next·?btn\d|btn·?next·?prev/.test(norm)) continue;
                            btnInActive = cand;
                            break;
                        }
                    }
                } catch (_) {}
                if (btnInActive) {
                    if ($ && typeof $ === 'function') {
                        try { $(btnInActive).trigger('click'); btnTriggered = true; } catch (_) {}
                    }
                    if (!btnTriggered) {
                        try { if (typeof btnInActive.click === 'function') { btnInActive.click(); btnTriggered = true; } } catch (_) {}
                    }
                    // 校验：按钮触发后 curSection 是否仍然是 page-active？
                    //   · 若站点 handler 生效 → curSection 不再 active / next section 变为 active → 直接返回成功
                    //   · 否则（无监听 / mock 环境）继续走 Step 1 手动 class 切换
                    if (btnTriggered) {
                        try {
                            const stillActive = curSection.classList && curSection.classList.contains('page-active');
                            const nextDom = curSection.nextElementSibling;
                            const nextIsActive = !!(nextDom && nextDom.classList && nextDom.classList.contains('page-active'));
                            if (!stillActive || nextIsActive) {
                                return { ok: true, reason: 'btn-next-triggered', from: currentIndex, to: currentIndex + 1, switchedBy: 'btn' };
                            }
                        } catch (_) { /* 校验异常 → 走手动 */ }
                    }
                }

                // ── Step 0b（滚动揭示页 / 自定义跳页 / 已揭示的 btn-base 下一页）──
                // 新版模板（如 .p1503 跳页 page-15→16、.p1602/.p1703/.p1803/.p1903/.p2003 滚动揭示）：
                //   这类页面的"下一页按钮"不是 .btn-next，而是：
                //   1) 滚动动画完成后由站点显示（display:block）的 .btn-base —— 点击后切页（若它同时是
                //      .btn-next，站点 handler 会同步 pageNums++，保证末页 pageNums>=7 防刷课守卫放行）
                //   2) 当前可见的滚动触发/跳页按钮（class token 形如 p\d{4}）—— 点击后站点开始滚动动画，
                //      稍后显示 .btn-base；跳页按钮（如 .p1503 经 BtnFn 注册）点击后立即切页。
                if (!btnInActive) {
                    // 1) 已揭示的 .btn-base（滚动完成、display != none）
                    let btnBase = null;
                    try {
                        if (curSection && typeof curSection.querySelector === 'function') {
                            const bb = curSection.querySelector('.btn-base, [class*="btn-base"]');
                            if (bb) {
                                let visible = true;
                                try {
                                    const st = bb.style && bb.style.display;
                                    if (st) visible = (st !== 'none');
                                    else if (typeof DOMUtils !== 'undefined') visible = !!DOMUtils.isVisible(bb);
                                } catch (_) { visible = true; }
                                if (visible) btnBase = bb;
                            }
                        }
                    } catch (_) {}
                    if (btnBase) {
                        let bbTriggered = false;
                        if ($ && typeof $ === 'function') {
                            try { $(btnBase).trigger('click'); bbTriggered = true; } catch (_) {}
                        }
                        if (!bbTriggered) {
                            try { if (typeof btnBase.click === 'function') { btnBase.click(); bbTriggered = true; } } catch (_) {}
                        }
                        if (bbTriggered) {
                            try {
                                const stillActive = curSection.classList && curSection.classList.contains('page-active');
                                const nextDom = curSection.nextElementSibling;
                                const nextIsActive = !!(nextDom && nextDom.classList && nextDom.classList.contains('page-active'));
                                if (!stillActive || nextIsActive) {
                                    return { ok: true, reason: 'btn-base-triggered', from: currentIndex, to: currentIndex + 1, switchedBy: 'btn-base' };
                                }
                            } catch (_) {}
                        }
                        // btn-base 已点但未切页：交给 Step 1 手动切换
                        btnInActive = btnBase;
                    } else {
                        // 2) 滚动触发 / 自定义跳页按钮：class token 形如 p\d{4}
                        // 站点 scroll() 页面常有装饰元素 .pXX02（img/图，仅做透明度动画）与功能触发按钮 .pXX03
                        // （.p1803/.p1703 等，点击后才滚动并显示 .btn-base）；.pXX03 才是真正触发，优先选择；
                        // 同时跳过已尝试过且未生效的元素（data-shuake-trigger-tried），避免反复点到装饰元素。
                        let trigger = null;
                        const pCands = [];
                        try {
                            if (curSection && typeof curSection.querySelectorAll === 'function') {
                                const els = curSection.querySelectorAll('[class*="p"]');
                                for (const c of els) {
                                    let cc = '';
                                    try { cc = String(c.className != null ? c.className : ''); } catch (_) {}
                                    if (!cc) { try { cc = String(c.getAttribute ? c.getAttribute('class') || '' : ''); } catch (_) {} }
                                    if (!/(^|\s)p\d{4}(\s|$)/.test(cc)) continue;
                                    if (c.getAttribute && c.getAttribute('data-shuake-trigger-tried') === '1') continue;
                                    let visible = true;
                                    try {
                                        const st = c.style && c.style.display;
                                        if (st) visible = (st !== 'none');
                                        else if (typeof DOMUtils !== 'undefined') visible = !!DOMUtils.isVisible(c);
                                    } catch (_) { visible = true; }
                                    if (visible) pCands.push(c);
                                }
                            }
                        } catch (_) {}
                        // 优先 .pXX03（scroll() 的功能触发按钮），其次任意 p\d{4}（如 .p1602/.p1503）
                        trigger = pCands.find(c => /(^|\s)p\d{2}03(\s|$)/.test(String(c.className || ''))) || pCands[0];
                        if (trigger) {
                            // 先标记已尝试：若点击后页面未推进/未揭示 .btn-base，下轮跳过它改试其他候选
                            try { if (typeof trigger.setAttribute === 'function') trigger.setAttribute('data-shuake-trigger-tried', '1'); } catch (_) {}
                            try { if (typeof trigger.click === 'function') trigger.click(); } catch (_) {}
                            try {
                                if (typeof trigger.dispatchEvent === 'function' && typeof MouseEvent === 'function') {
                                    trigger.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
                                }
                            } catch (_) {}
                            // 滚动触发：页面不立即切换，站点异步滚动后显示 .btn-base；
                            // 跳页按钮（.p1503 经 BtnFn 注册）点击后立即切页。统一乐观返回。
                            try { if (typeof Logger !== 'undefined' && Logger.debug) Logger.debug('[advancePage] 滚动触发/跳页按钮点击: ' + String(trigger.className || '')); } catch (_) {}
                            return { ok: true, reason: 'scroll-trigger', from: currentIndex, to: currentIndex + 1, switchedBy: 'scroll' };
                        }
                    }
                }

                // Step 1：手动对齐新版 JS 行为：
                //   a) 音效（p0102 特殊 or 默认 clickBase）
                //   b) parents('.page-item').next('.page-item') 切 active
                //   c) page-3 / page-2 音效联动
                const sounds = [];
                try {
                    const isP0102 = btnInActive && /(^|\s)p0102(\s|$)/.test(String(btnInActive.className || ''));
                    // 尝试播 clickStart / clickPbg （p0102 专用）或默认 clickBase
                    const clickBase = (w && w.clickBase) || (d.getElementById && d.getElementById('click-base'));
                    const clickStart = (w && w.clickStart) || (d.getElementById && d.getElementById('click-start'));
                    const clickPbg = (w && w.clickPbg) || (d.getElementById && d.getElementById('click-Pbg'));
                    if (isP0102) {
                        try { if (clickStart && typeof clickStart.play === 'function') { clickStart.play(); sounds.push('clickStart'); } } catch (_) {}
                        try { if (clickPbg && typeof clickPbg.play === 'function') { clickPbg.play(); sounds.push('clickPbg'); } } catch (_) {}
                    } else {
                        try { if (clickBase && typeof clickBase.play === 'function') { clickBase.play(); sounds.push('clickBase'); } } catch (_) {}
                    }
                } catch (_) {}

                // 取目标：parents('.page-item') 就是 curSection 本身，然后 next('.page-item')
                let nextSection = null;
                if ($ && typeof $ === 'function') {
                    try {
                        const $cur = $(curSection);
                        // 用户写法：$(this).parents(".page-item").next(".page-item")
                        let $parents = $cur.parents && $cur.parents('.page-item');
                        let $next = $parents && $parents.next ? $parents.next('.page-item') : $();
                        if (!$next || !$next.length) {
                            // 兜底：curSection 自己就是 .page-item（最常见）
                            $next = $cur.next ? $cur.next('.page-item') : $();
                        }
                        if ($next && $next.length) { nextSection = $next[0]; }
                    } catch (_) { nextSection = null; }
                }
                if (!nextSection) {
                    // DOM 兜底：Array next sibling（.page-item）
                    if (currentIndex >= 0 && currentIndex < sections.length - 1) nextSection = sections[currentIndex + 1];
                }
                if (!nextSection) return { ok: false, reason: 'no-next' };

                // 下一页是特殊问答/反馈页？不处理（与 forceAdvancePage 保持一致）
                const nextClass = nextSection.className || '';
                if (/page-a[qf]\d+|page-at\d+/.test(nextClass)) return { ok: false, reason: 'special-page' };

                // Step 1b：切 active（jQuery 优先，等价 addClass("page-active").siblings().removeClass("page-active")）
                let done = false;
                if ($ && typeof $ === 'function') {
                    try {
                        const $n = $(nextSection);
                        if ($n && typeof $n.addClass === 'function') {
                            $n.addClass('page-active').siblings().removeClass('page-active');
                            done = true;
                        }
                    } catch (_) { done = false; }
                }
                if (!done) {
                    const parent = curSection.parentNode;
                    if (parent && parent.querySelectorAll) {
                        parent.querySelectorAll('.page-active').forEach(el => {
                            try { el.classList.remove('page-active'); } catch (_) {}
                        });
                    }
                    nextSection.classList.add('page-active');
                    done = true;
                }
                if (!done) return { ok: false, reason: 'switch-failed' };

                // Step 1c：page-3 → setTimeout 500ms 播 clickP3 并停止 clickP2
                //          page-2 进入时不立即播 P2（用户 JS 是 page-3 切到时才停 P2，P2 启动在 page-at04→page-2 的 500ms setTimeout）
                try {
                    const page3El = d.querySelector('.page-3, [class*="page-3"].page-item');
                    if (page3El && page3El.classList && page3El.classList.contains('page-active')) {
                        const clickP3 = (w && w.clickP3) || (d.getElementById && d.getElementById('click-p3'));
                        const clickP2 = (w && w.clickP2) || (d.getElementById && d.getElementById('click-p2'));
                        try { if (clickP2) { clickP2.pause && clickP2.pause(); try { clickP2.currentTime = 0; } catch (_) {} sounds.push('pauseP2'); } } catch (_) {}
                        if (w && typeof w.setTimeout === 'function' && clickP3) {
                            w.setTimeout(() => {
                                try { if (typeof clickP3.play === 'function') clickP3.play(); } catch (_) {}
                            }, 500);
                            sounds.push('schedP3');
                        }
                    }
                } catch (_) {}

                // Step 2：setWidth 补齐（用户新版用 MutationObserver，但手动切时保险再调一次本地 setWidth）
                try { GraphicJsAdapter.setWidth(nextSection, d); } catch (_) {}
                try { if (w && typeof w.setWidth === 'function') w.setWidth(nextSection); } catch (_) {}

                return {
                    ok: true,
                    reason: done ? ($ ? 'jQuery-next-switch' : 'classList-next-switch') : 'switch-failed',
                    from: currentIndex,
                    to: currentIndex >= 0 ? currentIndex + 1 : -1,
                    sounds: sounds.join(',') || null
                };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 3-1. 反向翻页：对齐用户新版 $(".btn-prev").each handler ---
        // 用户新版 JS：
        //   $(".btn-prev").each(function(index) {
        //     $(this).click(function() {
        //       clickBase.play();
        //       clickP2.pause(); clickP2.currentTime = 0;
        //       $(this).parents(".page-item").prev(".page-item")
        //              .addClass("page-active").siblings().removeClass("page-active");
        //       if($(".page-2").hasClass("page-active")) {
        //         setTimeout(() => clickP2.play(), 200);
        //         clickP3.pause();
        //       }
        //     });
        //   });
        static retreatPage(doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            if (!d || typeof d.querySelectorAll !== 'function') return { ok: false, reason: 'no-doc' };
            try {
                const sections = GraphicJsAdapter.pageItems(d);
                if (!sections.length) return { ok: false, reason: 'no-page-item' };
                const curSection = GraphicJsAdapter.activePage(d);
                if (!curSection) return { ok: false, reason: 'no-active-page' };
                const currentIndex = sections.indexOf(curSection);
                if (currentIndex <= 0) return { ok: false, reason: 'already-first' };

                const $ = GraphicJsAdapter._$(w);
                const sounds = [];
                // Step 0：优先按钮 trigger
                let btnTriggered = false;
                try {
                    const btn = curSection.querySelector('.btn-prev, [class*="btn-prev"]');
                    if (btn) {
                        if ($ && typeof $ === 'function') { try { $(btn).trigger('click'); btnTriggered = true; } catch (_) {} }
                        if (!btnTriggered) { try { if (typeof btn.click === 'function') { btn.click(); btnTriggered = true; } } catch (_) {} }
                        // 校验是否真的切到 prev
                        if (btnTriggered) {
                            try {
                                const stillActive = curSection.classList && curSection.classList.contains('page-active');
                                const prevDom = curSection.previousElementSibling;
                                const prevIsActive = !!(prevDom && prevDom.classList && prevDom.classList.contains('page-active'));
                                if (!stillActive || prevIsActive) {
                                    return { ok: true, reason: 'btn-prev-triggered', from: currentIndex, to: currentIndex - 1, switchedBy: 'btn' };
                                }
                            } catch (_) {}
                        }
                    }
                } catch (_) {}

                // a) 播 clickBase + 默认停 clickP2
                const clickBase = (w && w.clickBase) || (d.getElementById && d.getElementById('click-base'));
                const clickP2 = (w && w.clickP2) || (d.getElementById && d.getElementById('click-p2'));
                try { if (clickBase && typeof clickBase.play === 'function') { clickBase.play(); sounds.push('clickBase'); } } catch (_) {}
                try {
                    if (clickP2) {
                        clickP2.pause && clickP2.pause();
                        try { clickP2.currentTime = 0; } catch (_) {}
                        sounds.push('pauseP2');
                    }
                } catch (_) {}

                // b) parents('.page-item').prev('.page-item').addClass.siblings.removeClass
                let prevSection = null;
                if ($ && typeof $ === 'function') {
                    try {
                        const $cur = $(curSection);
                        let $p = $cur.parents && $cur.parents('.page-item');
                        let $prev = $p && $p.prev ? $p.prev('.page-item') : $();
                        if (!$prev || !$prev.length) $prev = $cur.prev ? $cur.prev('.page-item') : $();
                        if ($prev && $prev.length) prevSection = $prev[0];
                    } catch (_) { prevSection = null; }
                }
                if (!prevSection && currentIndex >= 1) prevSection = sections[currentIndex - 1];
                if (!prevSection) return { ok: false, reason: 'no-prev' };

                let done = false;
                if ($ && typeof $ === 'function') {
                    try {
                        const $p = $(prevSection);
                        if ($p && typeof $p.addClass === 'function') {
                            $p.addClass('page-active').siblings().removeClass('page-active');
                            done = true;
                        }
                    } catch (_) { done = false; }
                }
                if (!done) {
                    const parent = prevSection.parentNode;
                    if (parent && parent.querySelectorAll) {
                        parent.querySelectorAll('.page-active').forEach(el => { try { el.classList.remove('page-active'); } catch (_) {}; });
                    }
                    prevSection.classList.add('page-active');
                    done = true;
                }
                if (!done) return { ok: false, reason: 'switch-failed' };

                // c) page-2 进入 → 200ms clickP2.play + clickP3 pause
                try {
                    const page2El = d.querySelector('.page-2, [class*="page-2"].page-item');
                    if (page2El && page2El.classList && page2El.classList.contains('page-active')) {
                        const clickP3 = (w && w.clickP3) || (d.getElementById && d.getElementById('click-p3'));
                        try { if (clickP3) { clickP3.pause && clickP3.pause(); sounds.push('pauseP3'); } } catch (_) {}
                        if (w && typeof w.setTimeout === 'function' && clickP2) {
                            w.setTimeout(() => { try { if (typeof clickP2.play === 'function') clickP2.play(); } catch (_) {} }, 200);
                            sounds.push('schedP2');
                        }
                    }
                } catch (_) {}

                try { GraphicJsAdapter.setWidth(prevSection, d); } catch (_) {}

                return {
                    ok: true,
                    reason: ($ && done ? 'jQuery-prev-switch' : 'classList-prev-switch'),
                    from: currentIndex,
                    to: currentIndex - 1,
                    sounds: sounds.join(',') || null
                };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 3-2. 答题问答"正常页"跳转：等价于 $(".btn-aq-n").each.click 的行为 ---
        // 用户 JS：
        //   $(".btn-aq-n").each(function(index) {
        //     $(this).click(function() {
        //       var at = $(this).parents("section").prop("id");
        //       at = parseInt(at) + 1;
        //       $(".page-" + at).addClass("page-active").siblings().removeClass("page-active");
        //     });
        //   });
        // 也就是说：当前活跃 <section id='NN'> → 切到 .page-(NN+1)。
        // 优先还是用 jQuery.trigger('click') 点当前 active 内的 .btn-aq-n；找不到时再按 id 手动切。
        static advanceAqNo(doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            if (!d || typeof d.querySelectorAll !== 'function') return { ok: false, reason: 'no-doc' };
            try {
                const activePage = GraphicJsAdapter.activePage(d);
                if (!activePage) return { ok: false, reason: 'no-active' };
                const $ = GraphicJsAdapter._$(w);
                let triggerReason = null;
                if ($ && typeof $ === 'function') {
                    try {
                        const $btn = $(activePage).find('.btn-aq-n, [class*="btn-aq-n"]');
                        if ($btn && $btn.length) {
                            $btn.trigger('click');
                            triggerReason = 'jQuery-btn-aq-n-trigger';
                        }
                    } catch (_) {}
                }
                if (!triggerReason) {
                    try {
                        const b = activePage.querySelector('.btn-aq-n, [class*="btn-aq-n"]');
                        if (b && typeof b.click === 'function') { b.click(); triggerReason = 'native-btn-aq-n-click'; }
                    } catch (_) {}
                }
                // 按 section.id + 1 手动切
                let rawId = '';
                try {
                    const btnEl = activePage.querySelector('.btn-aq-n, .btn-aq-y, [class*="btn-aq-n"], [class*="btn-aq-y"]');
                    if (btnEl && typeof btnEl.closest === 'function') {
                        const sec = btnEl.closest('section');
                        if (sec && typeof sec.getAttribute === 'function') rawId = sec.getAttribute('id') || '';
                    }
                } catch (_) {}
                if (!rawId && activePage && typeof activePage.getAttribute === 'function') rawId = activePage.getAttribute('id') || '';
                const idNum = parseInt(String(rawId || '').replace(/\D/g, ''), 10);
                if (!Number.isFinite(idNum) || Number.isNaN(idNum)) return { ok: false, reason: 'no-section-id' };
                const targetSel = `.page-${idNum + 1}`;
                const target = d.querySelector(targetSel);
                if (!target) return { ok: false, reason: 'no-target-' + (idNum + 1) };

                // 校验：按钮 trigger 后是否已经激活 target。若未激活（按钮无监听/监听漏跑）则手动切换。
                let switched = target.classList.contains('page-active');
                if (!switched) {
                    if ($ && typeof $ === 'function') {
                        try { $(target).addClass('page-active').siblings().removeClass('page-active'); switched = true; } catch (_) { switched = false; }
                    }
                }
                if (!switched) {
                    const parent = target.parentNode;
                    if (parent) parent.querySelectorAll('.page-active').forEach(el => { try { el.classList.remove('page-active'); } catch (_) {}; });
                    target.classList.add('page-active');
                    switched = true;
                }
                return { ok: true, reason: triggerReason ? triggerReason : 'class-switch-aq-n', from: idNum, to: (idNum + 1), switched: switched };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 3-3. 答题问答"正确/下一步"跳转：等价于 $(".btn-aq-y").each.click（id+2）---
        // 用户 JS：
        //   $(".btn-aq-y").each(function(index) {
        //     $(this).click(function() {
        //       var at = $(this).parents("section").prop("id");
        //       at = parseInt(at) + 2;
        //       $(".page-" + at).addClass("page-active").siblings().removeClass("page-active");
        //     });
        //   });
        static advanceAqYes(doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            if (!d || typeof d.querySelectorAll !== 'function') return { ok: false, reason: 'no-doc' };
            try {
                const activePage = GraphicJsAdapter.activePage(d);
                if (!activePage) return { ok: false, reason: 'no-active' };
                const $ = GraphicJsAdapter._$(w);
                let triggerReason = null;
                if ($ && typeof $ === 'function') {
                    try {
                        const $btn = $(activePage).find('.btn-aq-y, [class*="btn-aq-y"]');
                        if ($btn && $btn.length) {
                            $btn.trigger('click');
                            triggerReason = 'jQuery-btn-aq-y-trigger';
                        }
                    } catch (_) {}
                }
                if (!triggerReason) {
                    try {
                        const b = activePage.querySelector('.btn-aq-y, [class*="btn-aq-y"]');
                        if (b && typeof b.click === 'function') { b.click(); triggerReason = 'native-btn-aq-y-click'; }
                    } catch (_) {}
                }
                let rawId = '';
                try {
                    const btnEl = activePage.querySelector('.btn-aq-n, .btn-aq-y, [class*="btn-aq-n"], [class*="btn-aq-y"]');
                    if (btnEl && typeof btnEl.closest === 'function') {
                        const sec = btnEl.closest('section');
                        if (sec && typeof sec.getAttribute === 'function') rawId = sec.getAttribute('id') || '';
                    }
                } catch (_) {}
                if (!rawId && activePage && typeof activePage.getAttribute === 'function') rawId = activePage.getAttribute('id') || '';
                const idNum = parseInt(String(rawId || '').replace(/\D/g, ''), 10);
                if (!Number.isFinite(idNum) || Number.isNaN(idNum)) return { ok: false, reason: 'no-section-id' };
                const targetSel = `.page-${idNum + 2}`;
                const target = d.querySelector(targetSel);
                if (!target) return { ok: false, reason: 'no-target-' + (idNum + 2) };

                let switched = target.classList.contains('page-active');
                if (!switched) {
                    if ($ && typeof $ === 'function') {
                        try { $(target).addClass('page-active').siblings().removeClass('page-active'); switched = true; } catch (_) { switched = false; }
                    }
                }
                if (!switched) {
                    const parent = target.parentNode;
                    if (parent) parent.querySelectorAll('.page-active').forEach(el => { try { el.classList.remove('page-active'); } catch (_) {}; });
                    target.classList.add('page-active');
                    switched = true;
                }
                return { ok: true, reason: triggerReason ? triggerReason : 'class-switch-aq-y', from: idNum, to: (idNum + 2), switched: switched };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 4. 跳转到结束页并调用 finishWxCourse()（结束答题/完成学习） ---
        // 用户新版 JS（.btn-next-end 链路，与之前版本不同）：
        //   document.querySelector(".btn-next-end").addEventListener("click", function () {
        //     clickBase.play();
        //     document.querySelector(".page-reciprocal").classList.remove("page-active");
        //     document.querySelector(".page-end").classList.add("page-active");
        //     setTimeout(() => finishWxCourse(), 1000);
        //     Pbgfn();
        //   });
        // 注意：用户新版是 1000ms 后再 finishWxCourse()，而且同步播 clickBase + 立刻调用 Pbgfn() 渐隐背景音。
        // delayMs 语义：
        //   · 未传（undefined / null）→ 默认 1000ms（对齐用户新版 btn-next-end 的 setTimeout 1000ms）
        //   · 传值（数字）→ 调用方明确指定，用于 Controller 侧旧行为兜底 / 老页面兼容
        //   · 传 0 → 立刻调用 finishWxCourse（非默认，调用方显式要求）
        // 另外：无论按钮 trigger 是否命中，兜底都补做 clickBase.play() + Pbgfn() + class 切换 + finishWxCourse()，
        // 避免页面因为没有注册 addEventListener 而漏上报完成。
        //
        // ========== sdk.js 对齐新增 ==========
        // sdk.js 中 finishWxCourse = skip ? back : finish；且 finish() 内部不是单条 URL，
        // 是 4 条分支 + jsonp + uniqueNo(uuid) + csCapt 腾讯验证码 + csCom 评价跳转 +
        // from=dufe 发 parent.postMessage('finish', '*') + wx.miniProgram 导航栏改造。
        // 当页面全局 finishWxCourse 不存在（sdk.js 未注入 / 跨 iframe 取不到）时，这里通过
        // 一个独立的 _finishSDK() 方法等价执行 sdk.js 的 finish()。

        // 解析 URL querystring：与 sdk.js 保持"支持 queryString('name') = decodeURI(r[2])；没匹配返回 null"语义。
        // 但因为 window.location.search 只拿到 iframe 自己的 query，我们优先用 _pageWin().location.search，
        // 并回退顶部 window（真实用户页面大多数参数在 top 地址栏）。
        static _qs(name, wOverride) {
            const w = wOverride || GraphicJsAdapter._pageWin() || (typeof window !== 'undefined' ? window : null);
            if (!w) return null;
            try {
                const reg = new RegExp('(^|&)' + name + '=([^&]*)(&|$)', 'i');
                // 尝试 top.location.search（sdk.js 工作在 top），失败则回退当前 w。注意跨域抛错直接 catch。
                let search = '';
                try {
                    if (w.location && w.location.search) search = w.location.search.substring(1);
                } catch (_) { search = ''; }
                if (!search && w.top) try { search = w.top.location.search.substring(1); } catch (_) {}
                if (!search) return null;
                const r = search.match(reg);
                if (r !== null) { try { return decodeURI(r[2]); } catch (_) { return r[2]; } }
                return null;
            } catch (_) { return null; }
        }

        static _checkCode(data) {
            const code = Number(data && data.code);
            return Boolean(data) && (code === 0 || code === 1);
        }

        // sdk.js request：$.ajax POST/JSONP timeout:5000，success data=result or data；
        // code===0/1 → csCom=true 则 navigateToRating，否则 renderDialog；否则 alert(发送完成失败)；fail 同 alert。
        // 这里实现一个不依赖 $.ajax 的等价版本（脚本 GM_xmlhttpRequest 可用，且支持 JSONP —— 对 JSONP 仍走一次 <script> 注入）。
        static _requestSDK(url, data, jsonp, win, doc) {
            const w = win || GraphicJsAdapter._pageWin();
            const d = doc || GraphicJsAdapter._pageDoc();
            return new Promise((resolve) => {
                try {
                    // 构造 query
                    const makeQuery = (obj) => Object.keys(obj || {}).map(k => `${encodeURIComponent(k)}=${encodeURIComponent(String(obj[k]==null?'':obj[k]))}`).join('&');
                    const q = makeQuery(data);
                    if (jsonp) {
                        // 我们的"脚本侧"没有 jQuery jsonp 回调环境（sdk 用 $.ajax jsonp），
                        // 这里构造与真实 SDK 相同参数（callback=jQueryXXX）然后用 GM_xmlhttpRequest GET，
                        // 并解析返回结果，兼容 `jQuery({...})` / `/**/jQueryNNN( {...} )` / `{"code":...}` 三种格式。
                        const cbName = `jQuery_${Date.now()}_${Math.floor(Math.random() * 1e6)}`;
                        const sep = url.indexOf('?') >= 0 ? '&' : '?';
                        const full = `${url}${sep}callback=${encodeURIComponent(cbName)}${q ? '&' + q : ''}`;
                        const parseJsonp = (text) => {
                            try {
                                const t = String(text || '').trim();
                                // 去掉 /**/ 和 callback( ... )
                                const plain = t.replace(/^\/\*[\s\S]*?\*\//, '').replace(/^[A-Za-z0-9_$.]+\s*\(\s*/, '').replace(/\s*\)\s*;?\s*$/, '');
                                return JSON.parse(plain);
                            } catch (_) { return null; }
                        };
                        try {
                            if (typeof GM_xmlhttpRequest === 'function') {
                                GM_xmlhttpRequest({
                                    method: 'GET',
                                    url: full,
                                    responseType: 'text',
                                    timeout: 5000,
                                    onload: (r) => resolve(parseJsonp(r.responseText) || parseJsonp(r.response) || { code: -1, raw: (r.responseText||'').slice(0,200) }),
                                    onerror: () => resolve({ code: -1, error: 'xhr' }),
                                    ontimeout: () => resolve({ code: -1, error: 'timeout' })
                                });
                                return;
                            }
                        } catch (_) {}
                        // fallback: fetch
                        try {
                            if (w && typeof w.fetch === 'function') {
                                w.fetch(full, { method: 'GET' }).then(r => r.text()).then(t => resolve(parseJsonp(t) || {code:-2})).catch(() => resolve({ code: -3 }));
                                return;
                            }
                        } catch (_) {}
                        resolve({ code: -4, reason: 'no-jsonp-transport' });
                        return;
                    }
                    // 非 jsonp：POST + application/x-www-form-urlencoded；async=false 同步（sdk 语义），但我们 Promise 化。
                    let posted = false;
                    try {
                        if (typeof GM_xmlhttpRequest === 'function') {
                            GM_xmlhttpRequest({
                                method: 'POST',
                                url: url,
                                headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' },
                                data: q,
                                timeout: 5000,
                                responseType: 'json',
                                onload: (r) => {
                                    let j = null;
                                    try { if (typeof r.response === 'object') j = r.response; else j = JSON.parse(r.responseText); } catch (_) {}
                                    resolve(j || { code: -1 });
                                },
                                onerror: () => resolve({ code: -1 }),
                                ontimeout: () => resolve({ code: -1 })
                            });
                            posted = true;
                        }
                    } catch (_) { posted = false; }
                    if (!posted) {
                        try {
                            if (w && typeof w.fetch === 'function') {
                                w.fetch(url, {
                                    method: 'POST',
                                    headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' },
                                    body: q
                                }).then(r => r.json()).then(j => resolve(j)).catch(() => resolve({ code: -1 }));
                                posted = true;
                            }
                        } catch (_) { posted = false; }
                    }
                    if (!posted) resolve({ code: -1, reason: 'no-post-transport' });
                } catch (_) { resolve({ code: -1 }); }
            });
        }

        static _navigateToRating(win) {
            const w = win || GraphicJsAdapter._pageWin();
            const qs = (n) => GraphicJsAdapter._qs(n, w);
            const protocol = qs('protocol');
            const _protocol = protocol === 'true' ? 'https://' : 'http://';
            const courseId = qs('courseId') || '';
            const userCourseId = qs('userCourseId') || '';
            const projectId = qs('projectId') || '';
            const projectType = qs('projectType') || '';
            const userProjectId = qs('userProjectId') || '';
            const certificateId = qs('certificateId') || '';
            const userActivityState = qs('userActivityState') || '';
            const step = qs('step') || '';
            const index = qs('index') || '';
            const viewStep = qs('viewStep') || '';
            let url = `${_protocol}weiban.mycourse.cn/#/wk/comment?courseId=${encodeURIComponent(courseId)}&userCourseId=${encodeURIComponent(userCourseId)}&projectId=${encodeURIComponent(projectId)}&projectType=${encodeURIComponent(projectType)}&userProjectId=${encodeURIComponent(userProjectId)}`;
            url += `&certificateId=${encodeURIComponent(certificateId)}&userActivityState=${encodeURIComponent(userActivityState)}&step=${encodeURIComponent(step)}&index=${encodeURIComponent(index)}&viewStep=${encodeURIComponent(viewStep)}`;
            try { if (w && w.open) { w.open(url, '_parent'); return true; } } catch (_) {}
            return false;
        }

        static _renderDialog(doc, win) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = win || GraphicJsAdapter._pageWin();
            if (!d) return false;
            try {
                // 已有弹窗不再重复生成
                if (d.querySelector('.pop-jsv')) return true;
                try {
                    const $ = GraphicJsAdapter._$(w);
                    if ($ && typeof $ === 'function') {
                        const $link = $('<link />');
                        if ($link && $link.attr) { $link.attr({ rel: 'stylesheet', href: '/js/pop-item.css' }); $link.appendTo('head'); }
                        const fragment = [
                            '<div class="pop-jsv">',
                            '<div class="pop-jsv-content">',
                            '<h3 class="pop-jsv-title">恭喜你完成本微课学习！</h3>',
                            '<img src="/js/pop-icon-logo-icon.png" alt="" class="pop-jsv-logo" />',
                            '<div class="pop-jsv-btns">',
                            '<a href="javascript:;" class="pop-jsv-btn pop-jsv-prev">返回列表</a>',
                            '</div>',
                            '</div>',
                            '</div>'
                        ].join('');
                        try { $(fragment).appendTo('body'); } catch (e) { try{ console.error('[TRACE _renderDialog append catch]=', e && e.message); }catch(_){} }
                        try {
                            if (d.body && d.body.addEventListener) {
                                d.body.addEventListener('click', (e) => {
                                    try {
                                        const t = e && e.target;
                                        if (t && t.classList && t.classList.contains('pop-jsv-prev')) GraphicJsAdapter.backToList(d);
                                    } catch (_) {}
                                });
                            }
                        } catch (_) {}
                        return true;
                    } else {
                        try{ console.error('[TRACE _renderDialog $ null or not func. typeof=', typeof $, 'w.$=', w && typeof w.$, 'w.jQuery=', w && typeof w.jQuery); }catch(_){}
                    }
                } catch (e) { try{ console.error('[TRACE _renderDialog inner catch]=', e && e.message); }catch(_){} }
            } catch (e) { try{ console.error('[TRACE _renderDialog outer catch]=', e && e.message); }catch(_){} return false; }
            return false;
        }

        // sdk.js finish() 的 SDK 等价实现：4 条 URL 分支 + from=dufe + csCapt 腾讯验证码 + csCom 跳转 + uniqueNo(uuid)。
        // 返回 Promise<{ok, url, code}>。Controller 侧一般会 await 一下但不强求。
        static _finishSDK(doc, win) {
            const w = win || GraphicJsAdapter._pageWin();
            const d = doc || GraphicJsAdapter._pageDoc();
            const qs = (n) => GraphicJsAdapter._qs(n, w);
            const userCourseId = qs('userCourseId');
            const tenantCode = qs('tenantCode');
            const userActivityId = qs('userActivityId');
            const userId = qs('userId');
            const userProjectId = qs('userProjectId');
            const courseId = qs('courseId');
            const weiban = qs('weiban');
            const lyra = qs('lyra');
            const source = qs('source');
            const from = qs('from');
            const csCapt = qs('csCapt');
            const csCom = qs('csComm');
            const skip = qs('skip');
            const uuidVal = (typeof unsafeWindow !== 'undefined' && unsafeWindow && unsafeWindow.uuid)
                || (w && w.uuid)
                || null;

            const handleResp = (resp, urlUsed) => {
                try {
                    const data = resp.result || resp;
                    const ok = GraphicJsAdapter._checkCode(data);
                    if (ok) {
                        try {
                            if (csCom === 'true') GraphicJsAdapter._navigateToRating(w);
                            else GraphicJsAdapter._renderDialog(d, w);
                        } catch (_) {}
                    } else {
                        try { if (typeof alert === 'function') alert('发送完成失败'); } catch (_) {}
                    }
                    return { ok, url: urlUsed, code: data && data.code, resp };
                } catch (e) { return { ok: false, url: urlUsed, code: -999, error: e && e.message }; }
            };

            // skip=?sdk.js: global.finishWxCourse = skip ? back : finish；
            // 若 URL 带 skip，我们只走 back（等价行为）而不是发送完成请求。
            if (skip && !['null', 'undefined', 'false', '0', ''].includes(String(skip))) {
                try {
                    GraphicJsAdapter.backToList(d);
                    return Promise.resolve({ ok: true, url: 'skip→back', code: 0 });
                } catch (_) { return Promise.resolve({ ok: false, url: 'skip→back', code: -1 }); }
            }

            // from=dufe → 东财 iframe：向父页面发消息（sdk.js），不上报自身服务
            if (from === 'dufe') {
                try {
                    if (w && w.parent && typeof w.parent.postMessage === 'function') w.parent.postMessage('finish', '*');
                    return Promise.resolve({ ok: true, url: 'dufe→postMessage', code: 0 });
                } catch (e) { return Promise.resolve({ ok: false, url: 'dufe→postMessage', code: -1, error: e && e.message }); }
            }

            const WEIBAN = 'weiban';
            const LYRA = 'lyra';
            const MOON = 'moon';
            let url = '';
            let opts = {};
            let jsonp = false;

            if (weiban !== WEIBAN) {
                if (lyra === LYRA) {
                    // 安全实训
                    url = 'https://lyra.mycourse.cn/lyraapi/study/course/finish.api';
                } else {
                    // 主题活动
                    url = 'https://open.mycourse.cn/proteus/usercourse/finish.do';
                }
            } else if (source === MOON) {
                url = 'https://moon.mycourse.cn/moonapi/api/study/activity/microCourse/v1/finishedCourse';
            } else {
                // 默认微班 v2：第一次走 `${v2}/${userCourseId}.do` → 验证码 check 通过后走 `${v2}/${data}.do`
                // 因为我们没有验证码就直接走 v2/${userCourseId} 分支
                url = `https://weiban.mycourse.cn/pharos/usercourse/v2/${userCourseId}.do`;
            }

            if (lyra === LYRA) {
                opts = { userActivityId: userActivityId || '' };
            } else {
                opts = { userCourseId: userCourseId || '', tenantCode: tenantCode || '' };
                jsonp = true;
            }
            if (uuidVal) opts.uniqueNo = String(uuidVal);

            // csCapt === 'true' → 腾讯验证码 TencentCaptcha(195119536, callback, {userLanguage:'zh-cn'})
            //  成功后 $.post check.do (userId, userCourseId, userProjectId, courseId, tenantCode, randstr, ticket)
            //   → 返回 data 字符串 → 再 request(`${v2}/${data}.do`, opts, jsonp)
            // 若主动关闭：res.ret === 2 → alert + back()。
            // 无验证码环境（无 window.TencentCaptcha / catch err）：按 sdk.js try/catch 静默跳过 → 继续走原 request(url)
            let tryCaptcha = (weiban === WEIBAN && csCapt === 'true');
            if (tryCaptcha) {
                try {
                    const TC = (w && w.TencentCaptcha) || (typeof TencentCaptcha !== 'undefined' ? TencentCaptcha : undefined);
                    if (TC && typeof w.$ === 'function' && w.$ && w.$.post) {
                        // 真.腾讯验证码：交给腾讯弹框，异步返回
                        return new Promise((resolve) => {
                            try {
                                const captcha = new TC('195119536', (res) => {
                                    try {
                                        if (res && res.ret === 2) {
                                            try { if (typeof alert === 'function') alert('因主动关闭验证，即将返回课程列表，请重新学习'); } catch (_) {}
                                            try { GraphicJsAdapter.backToList(d); } catch (_) {}
                                            resolve({ ok: false, url: url, code: -2, reason: 'captcha-cancelled' });
                                            return;
                                        }
                                        w.$.post('https://weiban.mycourse.cn/pharos/usercourse/check.do', {
                                            userId: userId || '',
                                            userCourseId: userCourseId || '',
                                            userProjectId: userProjectId || '',
                                            courseId: courseId || '',
                                            tenantCode: tenantCode || '',
                                            randstr: res && res.randstr || '',
                                            ticket: res && res.ticket || ''
                                        }).done((resJSON) => {
                                            try {
                                                let token = '';
                                                if (typeof resJSON === 'string') {
                                                    try { token = (JSON.parse(resJSON) || {}).data; } catch (_) {}
                                                } else {
                                                    token = resJSON && resJSON.data;
                                                }
                                                const finalUrl = `https://weiban.mycourse.cn/pharos/usercourse/v2/${token}.do`;
                                                GraphicJsAdapter._requestSDK(finalUrl, opts, jsonp, w, d).then(resp => {
                                                    resolve(handleResp(resp, finalUrl));
                                                }).catch(() => resolve({ ok: false, url: finalUrl, code: -1 }));
                                            } catch (e) { resolve({ ok: false, url: url, code: -1, error: e && e.message }); }
                                        }).fail((xhr) => {
                                            try { if (typeof alert === 'function') alert((xhr && xhr.msg) || 'check.do 失败'); } catch (_) {}
                                            resolve({ ok: false, url: 'check.do', code: -1 });
                                        });
                                    } catch (e) { resolve({ ok: false, url: 'captcha', code: -1, error: e && e.message }); }
                                }, { userLanguage: 'zh-cn' });
                                if (captcha && typeof captcha.show === 'function') captcha.show();
                                else {
                                    // captcha 对象不存在，降级普通 URL 请求
                                    GraphicJsAdapter._requestSDK(url, opts, jsonp, w, d).then(resp => resolve(handleResp(resp, url)));
                                }
                            } catch (e) {
                                GraphicJsAdapter._requestSDK(url, opts, jsonp, w, d).then(resp => resolve(handleResp(resp, url)));
                            }
                        });
                    } else {
                        // mock 或 没有 TencentCaptcha 的环境，sdk.js try/catch 静默，继续走原 URL
                    }
                } catch (_) { /* 静默：跟 sdk.js 的 try{captcha.show}catch(err) 一致 */ }
            }

            return GraphicJsAdapter._requestSDK(url, opts, jsonp, w, d).then(resp => handleResp(resp, url));
        }

        // ========== sdk.js 对齐：环境初始化 ==========
        // 1) 顶部 WeixinJSBridge 调用 hideOptionMenu（屏蔽微信右上角功能按钮）
        // 2) wx.miniProgram.getEnv：miniprogram=true 时重写 backToList/back = navigateBack，重写 navigateToRating = redirectTo
        // 3) 东财 iframe 对接高度：parent.postMessage({ type:'resize', height: parseInt(getComputedStyle(.page-slide).height,10) }, '*')
        // 以上三点 sdk.js 在脚本体顶层执行，所以我们在"首次判定 hasNativeSupport 为真且 GraphicJsAdapter._sdkEnvInstalled !== true"时执行一次。
        static _installSDKEnv(doc, win) {
            const w = win || GraphicJsAdapter._pageWin();
            const d = doc || GraphicJsAdapter._pageDoc();
            try {
                if (GraphicJsAdapter._sdkEnvInstalled) return;
                GraphicJsAdapter._sdkEnvInstalled = true;

                // 3. 东财 resize postMessage —— 只在能拿到 .page-slide 时才发
                try {
                    if (d && typeof d.querySelector === 'function' && typeof window !== 'undefined') {
                        const slide = d.querySelector('.page-slide');
                        if (slide && w && w.parent && typeof w.parent.postMessage === 'function') {
                            let h = 0;
                            try {
                                const style = (typeof getComputedStyle === 'function')
                                    ? getComputedStyle(slide)
                                    : (w && typeof w.getComputedStyle === 'function' ? w.getComputedStyle(slide) : null);
                                if (style && style.height) h = parseInt(style.height, 10);
                            } catch (_) {}
                            if (Number.isFinite(h) && h > 0) w.parent.postMessage({ type: 'resize', height: h }, '*');
                        }
                    }
                } catch (_) {}

                // 1. WeixinJSBridge
                try {
                    const ready = () => {
                        try {
                            const bridge = (w && w.WeixinJSBridge) || (typeof WeixinJSBridge !== 'undefined' ? WeixinJSBridge : undefined);
                            if (bridge && bridge.call) bridge.call('hideOptionMenu');
                        } catch (_) {}
                    };
                    const wxBridge = (w && w.WeixinJSBridge) || (typeof WeixinJSBridge !== 'undefined' ? WeixinJSBridge : undefined);
                    if (!wxBridge || !wxBridge.invoke) {
                        if (d && d.addEventListener) d.addEventListener('WeixinJSBridgeReady', ready, false);
                        else if (typeof document !== 'undefined' && document.addEventListener) document.addEventListener('WeixinJSBridgeReady', ready, false);
                    } else {
                        ready();
                    }
                } catch (_) {}

                // 2. wx.miniProgram.getEnv → 覆盖 backToList / navigateToRating
                try {
                    const wxObj = (w && w.wx) || (typeof wx !== 'undefined' ? wx : null);
                    if (wxObj && wxObj.miniProgram && typeof wxObj.miniProgram.getEnv === 'function') {
                        wxObj.miniProgram.getEnv(function (res) {
                            try {
                                if (res && res.miniprogram) {
                                    const qs = (n) => GraphicJsAdapter._qs(n, w);
                                    const courseId = qs('courseId') || '';
                                    const userCourseId = qs('userCourseId') || '';
                                    const projectId = qs('projectId') || '';
                                    const projectType = qs('projectType') || '';
                                    const userProjectId = qs('userProjectId') || '';
                                    // 对齐 sdk.js：global.backToList = back = wx.miniProgram.navigateBack
                                    const navigateBack = () => { try { wxObj.miniProgram.navigateBack(); } catch (_) {} };
                                    if (w) {
                                        w.backToList = navigateBack;
                                        w.back = navigateBack;
                                        w._wxRatingOverride = true;
                                        GraphicJsAdapter._navigateToRating = function (winOverride) {
                                            try {
                                                wxObj.miniProgram.redirectTo({
                                                    url: `/pages/learning/course-rating/index?courseId=${encodeURIComponent(courseId)}&userCourseId=${encodeURIComponent(userCourseId)}&projectId=${encodeURIComponent(projectId)}&projectType=${encodeURIComponent(projectType)}&userProjectId=${encodeURIComponent(userProjectId)}`
                                                });
                                                return true;
                                            } catch (_) { return false; }
                                        };
                                    }
                                }
                            } catch (_) {}
                        });
                    }
                } catch (_) {}

                // 4. 确保全局 finishWxCourse / backToList 与 SDK 对齐（当 iframe 注入缺失时）
                //    sdk.js: global.finishWxCourse = skip ? back : finish；当页面没有 finishWxCourse 时，
                //    我们把 finishWxCourse 设置成一个"调度 _finishSDK 并忽略返回"的同步触发函数，
                //    保持调用处 typeof === 'function' 可用。
                try {
                    if (w && typeof w.finishWxCourse !== 'function') {
                        // 防风控：avoidDirectFinish=true 时不注入"直接请求完成接口"的 finishWxCourse，
                        // 改为 no-op 占位（保证 typeof function），让站点 item.js 原生链路/平台 watch 自行完成；
                        // false 时保持 _finishSDK 兜底。
                        const _avoidFinish = (typeof CONFIG !== 'undefined' && CONFIG.avoidDirectFinish);
                        w.finishWxCourse = _avoidFinish
                            ? function () { try { Logger.info('[GraphicJsAdapter] finishWxCourse no-op（avoidDirectFinish，不直接请求完成接口）'); } catch (_) {} }
                            : function () { GraphicJsAdapter._finishSDK(d, w); };
                    }
                    if (w && typeof w.backToList !== 'function') {
                        w.backToList = function () {
                            // 优先 history.back （与 sdk.js let back = window.history.back 一致）
                            try { if (w.history && typeof w.history.back === 'function') { w.history.back(); return; } } catch (_) {}
                            try { if (typeof history !== 'undefined' && history && typeof history.back === 'function') history.back(); } catch (_) {}
                        };
                        w.back = w.backToList;
                    }
                } catch (_) {}

                // 5. 给 body 绑定 sdk.js pop-jsv-prev 点击 → backToList（等价于 $('body').on('click','.pop-jsv-prev',back)）
                try {
                    if (d && d.body && typeof d.body.addEventListener === 'function') {
                        const handler = function (ev) {
                            try {
                                const t = ev && ev.target;
                                if (t && t.classList && t.classList.contains('pop-jsv-prev')) {
                                    GraphicJsAdapter.backToList(d);
                                }
                            } catch (_) {}
                        };
                        if (!d.body.__skSDKPrevBound) { d.body.addEventListener('click', handler); d.body.__skSDKPrevBound = true; }
                    }
                } catch (_) {}
            } catch (_) {}
        }

        static completeCourse(doc, delayMs) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            const hasExplicitDelay = typeof delayMs !== 'undefined' && delayMs !== null;
            // 用户新版默认是 1000ms delay（setTimeout(() => finishWxCourse(), 1000)）
            const delay = hasExplicitDelay ? (Number.isFinite(delayMs) ? delayMs : 1000) : 1000;
            if (!d) return { ok: false, reason: 'no-doc' };
            try {
                // 0) clickBase.play()：用户新版 btn-next-end click 第一行
                try {
                    const clickBase = (w && w.clickBase) || (d.getElementById && d.getElementById('click-base'));
                    if (clickBase && typeof clickBase.play === 'function') try { clickBase.play(); } catch (_) {}
                } catch (_) {}

                let switched = false;
                const $ = GraphicJsAdapter._$(w);

                // 防刷课守卫兼容：新版模板 .btn-next-end 监听里有
                //   if (pageNums >= 7) { ...finishWxCourse() } else { alert("请不要刷课!") }
                // pageNums 是站点闭包里的 let（无法从外部读写），只能靠真实 .btn-next 点击累加。
                // 若累加不足 7，alert() 会同步阻塞线程导致后续 class 切换/finishWxCourse 永远执行不到，
                // 因此在点击 btn-next-end 期间临时抑制 alert。
                let _savedAlert = null;
                try {
                    if (w && typeof w.alert === 'function') { _savedAlert = w.alert; w.alert = function () {}; }
                } catch (_) {}

                // 4a. 优先：.btn-next-end.trigger('click') + 原生 click + dispatchEvent
                if ($ && typeof $ === 'function') {
                    try {
                        const $btnEnd = $('.btn-next-end, [class*="btn-next-end"], a.btn-next-end');
                        if ($btnEnd && $btnEnd.length) {
                            $btnEnd.trigger('click');
                            try {
                                const el = $btnEnd[0];
                                if (el) {
                                    if (typeof el.click === 'function') el.click();
                                    if (typeof el.dispatchEvent === 'function' && typeof MouseEvent === 'function') {
                                        el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
                                    }
                                }
                            } catch (_) {}
                            try {
                                const endSec = d.querySelector('.page-end, [class*="page-end"].page-item');
                                switched = !!(endSec && endSec.classList && endSec.classList.contains('page-active'));
                            } catch (_) { switched = false; }
                            try { Logger.info('[GraphicJsAdapter] btn-next-end.click 已触发（用户新版 1000ms+Pbgfn 监听链）'); } catch (_) {}
                        }
                    } catch (_) {}
                }
                try {
                    const btnEnd = d.querySelector('.btn-next-end, [class*="btn-next-end"], a.btn-next-end');
                    if (btnEnd) {
                        try { if (typeof btnEnd.click === 'function') btnEnd.click(); } catch (_) {}
                        try {
                            if (typeof btnEnd.dispatchEvent === 'function' && typeof MouseEvent === 'function') {
                                btnEnd.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
                            }
                        } catch (_) {}
                        const endSec = d.querySelector('.page-end, [class*="page-end"].page-item');
                        if (endSec && endSec.classList && endSec.classList.contains('page-active')) switched = true;
                    }
                } catch (_) {}

                // 4b. class 切换兜底：.page-reciprocal → .page-end（与用户新版等价 classList 操作）
                try {
                    const last = d.querySelector('.page-reciprocal, [class*="page-reciprocal"]');
                    const endSec = d.querySelector('.page-end, [class*="page-end"].page-item');
                    if (last && last.classList && last.classList.contains('page-active')) {
                        try { last.classList.remove('page-active'); } catch (_) {}
                    }
                    if (endSec && !endSec.classList.contains('page-active')) {
                        try { endSec.classList.add('page-active'); switched = true; } catch (_) {}
                    } else if (endSec && endSec.classList.contains('page-active')) {
                        switched = true;
                    }
                } catch (_) {}

                // jQuery 兜底 addClass / siblings.removeClass
                if (!switched && $ && typeof $ === 'function') {
                    try {
                        const $end = $('.page-end');
                        if ($end && $end.length && !$end.hasClass('page-active')) {
                            $end.addClass('page-active').siblings().removeClass('page-active');
                            switched = true;
                        }
                    } catch (_) {}
                }

                // 4c. Pbgfn()：用户新版 btn-next-end 监听里**同步**调用（不等 finishWxCourse）。
                //     若页面没有全局 Pbgfn，则用本地 GraphicJsAdapter.Pbgfn(d) 兜底。
                //     先恢复被抑制的 alert（站点 finishWxCourse 异步链路不再需要抑制）。
                try { if (_savedAlert && w) w.alert = _savedAlert; } catch (_) {}
                let calledPbgfn = false;
                try {
                    if (w && typeof w.Pbgfn === 'function') {
                        try { w.Pbgfn(); calledPbgfn = true; } catch (_) { calledPbgfn = false; }
                    }
                    if (!calledPbgfn) {
                        try {
                            const pbgRes = GraphicJsAdapter.Pbgfn(d);
                            calledPbgfn = !!(pbgRes && pbgRes.ok);
                        } catch (_) {}
                    }
                } catch (_) {}

                // 4d. finishWxCourse()：用户新版是 setTimeout 1000ms 后调用。
                //     这里始终再调用一次（用户新版监听已经 setTimeout 1000ms 的话，就会有两次调用，
                //     finishWxCourse 通常请求幂等/服务端节流，没问题；若监听没生效则保证至少有一次上报）。
                //
                //     sdk.js 对齐新增：当 w.finishWxCourse 不存在（sdk.js 未注入）时，
                //     我们主动调用 GraphicJsAdapter._finishSDK() 等价完成 4 条 URL 分支上报，
                //     不是"跳过 JS 级完成调用"。calledFinish 因此区分三种：native / sdk-standalone / false。
                let calledFinish = false;
                let scheduledKey = null;
                let finishKind = null; // 'native' | 'sdk' | null
                const doFinish = () => {
                    try {
                        if (w && typeof w.finishWxCourse === 'function') {
                            try { w.finishWxCourse(); calledFinish = true; finishKind = 'native'; } catch (_) { calledFinish = false; }
                            try { Logger.info(`[GraphicJsAdapter] finishWxCourse() 已调用 (delay=${delay}ms, Pbgfn=${calledPbgfn})`); } catch (_) {}
                        }
                        if (!calledFinish && !(typeof CONFIG !== 'undefined' && CONFIG.avoidDirectFinish)) {
                            // 防风控：avoidDirectFinish=true 时跳过 _finishSDK 直接请求完成接口，
                            // 仅保留站点原生 finishWxCourse 链路（上面 w.finishWxCourse() 已调用）。
                            try {
                                const sdkRes = GraphicJsAdapter._finishSDK(d, w);
                                calledFinish = true;
                                finishKind = 'sdk';
                                try { Logger.info(`[GraphicJsAdapter] _finishSDK 已启动（sdk.js 对齐 4 分支 / delay=${delay}ms, Pbgfn=${calledPbgfn})`); } catch (_) {}
                            } catch (e2) {
                                try { Logger.debug(`[GraphicJsAdapter] 页面未暴露 finishWxCourse 且 _finishSDK 启动失败: ${e2 && e2.message}`); } catch (_) {}
                            }
                        }
                    } catch (_) {}
                };
                if (delay > 0) {
                    if (w && typeof w.setTimeout === 'function') { scheduledKey = w.setTimeout(doFinish, delay); }
                    else { setTimeout(doFinish, delay); }
                } else {
                    doFinish();
                }

                return {
                    ok: switched || !!w,
                    reason: calledFinish ? (finishKind === 'native' ? 'finishWxCourse' : 'finishSDK') : (switched ? 'page-end-only' : 'no-native-fn'),
                    finishKind: finishKind,
                    delay: delay,
                    pbgfn: calledPbgfn,
                    scheduledDelay: (delay > 0) ? delay : 0
                };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 4.5 站点学习进度上报适配（callApinext / jupiterapi statusercourse v1/next） ---
        // 用户提供的站点 item.js：callApinext(nextprev, finish, nonstrMap) 每次翻页(finish=2)/完成(finish=1)
        // 都向 jupiterapi/api/statusercourse/v1/next 上报
        //   {userCourseId, uniqueNo, userId, courseId, userProjectId, finished, step, nonstr, tenantCode}
        // AES-CBC(Pkcs7) 加密后 POST {data: encryptedBase64}。
        // 站点侧以 step 单调递增 + nonstr(step 3/5/6/9/12) + uniqueNo(uuid) 判定"真实学习轨迹"，
        // 缺上报 / 乱序 / 跳 step 会被判刷课 → 701 风控。本适配器在翻页成功后触发上报，
        // 优先调用站点原生 callApinext（行为 100% 一致），缺省时用页面 CryptoJS 等价实现。
        static get NONSTR_MAP() {
            return { 3: '9UWDQO', 5: 'kGiSG', 6: 'jgDPf', 9: 'QUi9aQ5p9a', 12: 'PG4rlD' };
        }
        // 风控页检测：页面带站点学习轨迹/反欺诈上报 JS（callApinext / jupiterapi statusercourse /
        // antiFraudIdentifyAnalysis / jupitersse）时，站点会按"每页停留时长"判定真实学习，
        // 翻页过快会被判刷课 → 701。命中则启用慢速翻页。
        static isRiskControlledPage(doc) {
            try {
                const w = GraphicJsAdapter._pageWin();
                if (w) {
                    if (typeof w.callApinext === 'function') return true;
                    if (typeof w.saveAIZGComment === 'function') return true;
                }
            } catch (_) {}
            // 收集所有可达文档：父级 doc + 课程 iframe（递归 _courseFrame）+ 直接子 iframe 内容，
            // 避免仅扫父级 doc 而漏掉 iframe 内的风控 JS（weiban #/course/detail 路由下课程内容在 iframe 内）。
            const docs = [];
            try { docs.push(doc || document); } catch (_) {}
            try { const fr = GraphicJsAdapter._courseFrame(); if (fr && fr.doc && fr.doc !== (doc || document)) docs.push(fr.doc); } catch (_) {}
            try {
                const d0 = doc || GraphicJsAdapter._pageDoc();
                if (d0 && typeof d0.querySelectorAll === 'function') {
                    const ifs = d0.querySelectorAll('iframe');
                    const im = Math.min(ifs.length, 10);
                    for (let i = 0; i < im; i++) {
                        try {
                            const cd = ifs[i].contentDocument || (ifs[i].contentWindow && ifs[i].contentWindow.document);
                            if (cd && cd !== (doc || document) && docs.indexOf(cd) < 0) docs.push(cd);
                        } catch (_) {}
                    }
                }
            } catch (_) {}
            for (const d of docs) {
                if (!d || typeof d.querySelectorAll !== 'function') continue;
                try {
                    const scripts = d.querySelectorAll('script');
                    const n = Math.min(scripts.length, 30);
                    for (let i = 0; i < n; i++) {
                        const t = (scripts[i] && scripts[i].textContent) || '';
                        if (t.indexOf('antiFraudIdentifyAnalysis') >= 0 || t.indexOf('callApinext') >= 0 ||
                            t.indexOf('jupitersse') >= 0 || t.indexOf('statusercourse') >= 0) return true;
                    }
                } catch (_) {}
            }
            return false;
        }
        static _stepState(win) {
            const w = win || GraphicJsAdapter._pageWin();
            if (!w) return { nextnum: 0, nextnummax: 0, uuid: null };
            if (!w.__skStepState) w.__skStepState = { nextnum: 0, nextnummax: 0, uuid: null };
            return w.__skStepState;
        }
        static _genUUID() {
            let d = new Date().getTime();
            return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
                const r = (d + Math.random() * 16) % 16 | 0; d = Math.floor(d / 16);
                return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
            });
        }
        // 翻页成功后调用（finish=2）；课程完成上报(finish=1)由 .btn-next-end 站点 handler 的
        // callApinext("next",1) 触发，脚本不重复补报（避免 step 双跳）。
        static reportStep(doc, win, finish) {
            const w = win || GraphicJsAdapter._pageWin();
            const d = doc || GraphicJsAdapter._pageDoc();
            try {
                // 1) 优先调用站点原生 callApinext（内部 AES 加密 + ajax，与真实用户行为一致）
                if (w && typeof w.callApinext === 'function') {
                    const nonstrMap = (w && w.nonstrMap) || GraphicJsAdapter.NONSTR_MAP;
                    try {
                        w.callApinext('next', finish || 2, nonstrMap);
                        // 锁定风控页：该页确实有 callApinext 上报通道 → 后续翻页启用慢速
                        try {
                            if (typeof State !== 'undefined') { State._riskPageHit = true; State._riskPageSig = ''; }
                        } catch (_) {}
                        try { Logger.debug(`[进度上报] callApinext('next', ${finish || 2}) 站点原生触发`); } catch (_) {}
                        return { ok: true, native: true, finish: finish || 2 };
                    } catch (_) {}
                }
                // 2) 站点无 callApinext：页面加载了 CryptoJS + jQuery 时等价上报（AES-256-CBC）
                const C = (w && w.CryptoJS) || (typeof CryptoJS !== 'undefined' ? CryptoJS : null);
                const $ = (w && w.$) || (w && w.jQuery) || null;
                if (!C || !$) return { ok: false, reason: 'no-callapinext-no-crypto' };
                const st = GraphicJsAdapter._stepState(w);
                if (!st.uuid) {
                    st.uuid = (typeof w.generateUUID === 'function') ? w.generateUUID() : GraphicJsAdapter._genUUID();
                }
                const qs = (n) => GraphicJsAdapter._qs(n, w);
                const f = finish || 2;
                if (f === 2) {
                    st.nextnum += 1;
                    if (st.nextnummax >= st.nextnum) return { ok: false, reason: 'dup-step' };
                    st.nextnummax = st.nextnum;
                }
                const nonstr = GraphicJsAdapter.NONSTR_MAP[st.nextnum] || '';
                const data = {
                    userCourseId: qs('userCourseId'), uniqueNo: st.uuid, userId: qs('userId'),
                    courseId: qs('courseId'), userProjectId: qs('userProjectId'),
                    finished: f, step: st.nextnum, nonstr: nonstr, tenantCode: qs('tenantCode')
                };
                const key = C.enc.Utf8.parse('KkGv9d8E5jYb2xHwL3ZqRpXoNt6MmSge');
                const iv = C.enc.Utf8.parse('KkGv9d8E5jYb2xHwL3'); // key 前 16 字节
                const encrypted = C.AES.encrypt(JSON.stringify(data), key, { iv: iv, mode: C.mode.CBC, padding: C.pad.Pkcs7 });
                const encryptedBase64 = C.enc.Base64.stringify(C.enc.Utf8.parse(encrypted.toString()));
                $.ajax({
                    url: 'https://weiban.mycourse.cn/jupiterapi/api/statusercourse/v1/next',
                    method: 'POST', contentType: 'application/json', dataType: 'json',
                    data: JSON.stringify({ data: encryptedBase64 }),
                    success: function () {}, error: function () {}
                });
                try { Logger.debug(`[进度上报] jupiterapi statusercourse step=${st.nextnum} finish=${f}（CryptoJS 等价实现）`); } catch (_) {}
                // 锁定风控页：页面确实有 jupiterapi 进度上报通道 → 后续翻页启用慢速
                try {
                    if (typeof State !== 'undefined') { State._riskPageHit = true; State._riskPageSig = ''; }
                } catch (_) {}
                return { ok: true, native: false, finish: f, step: st.nextnum };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 5. 返回列表：等价于 document.querySelector(".back-list").addEventListener("click", backToList) ---
        // sdk.js 对齐：优先调用 w.backToList（可能被 wx.miniProgram.getEnv 重写为 navigateBack），
        //             否则走 back = window.history.back（sdk.js 默认实现）。
        static backToList(doc) {
            const w = GraphicJsAdapter._pageWin();
            const d = doc || GraphicJsAdapter._pageDoc();
            try {
                // 确保 SDK 环境（wx / history fallback）已注入（sdk.js 未挂时仍能行为一致）
                try { GraphicJsAdapter._installSDKEnv(d, w); } catch (_) {}

                if (w && typeof w.backToList === 'function') {
                    try {
                        w.backToList();
                        try { Logger.info('[GraphicJsAdapter] backToList() 已调用'); } catch (_) {}
                        return { ok: true, reason: 'backToList-called' };
                    } catch (_) {}
                }
                // sdk.js 默认实现：back = window.history.back
                let usedHistory = false;
                try {
                    if (w && w.history && typeof w.history.back === 'function') { w.history.back(); usedHistory = true; }
                    else if (typeof history !== 'undefined' && history && typeof history.back === 'function') { history.back(); usedHistory = true; }
                } catch (_) { usedHistory = false; }
                if (usedHistory) {
                    try { Logger.info('[GraphicJsAdapter] backToList() → history.back'); } catch (_) {}
                    return { ok: true, reason: 'history-back' };
                }
                return { ok: false, reason: 'no-backToList' };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 6. 到达倒数第二页（page-reciprocal）时检查并推进到结束页（用于答题完成场景） ---
        // 当前页若是 .page-reciprocal 且 可见 .btn-next-end → 直接走 completeCourse（先到 .page-end → finishWxCourse）
        static tryFinishFromReciprocal(doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            if (!d || typeof d.querySelector !== 'function') return { ok: false, reason: 'no-doc' };
            try {
                const activePage = GraphicJsAdapter.activePage(d);
                if (!activePage) return { ok: false, reason: 'no-active' };
                const cls = activePage.className || '';
                const isReciprocal = /(^|\s)page-reciprocal(\s|$)/.test(cls) || /page-reciprocal/i.test(cls);
                if (!isReciprocal) return { ok: false, reason: 'not-reciprocal' };
                // 若页面还有可见的 .btn-next-end（答题完成按钮），直接推进结束流程
                const btnEnd = d.querySelector('.btn-next-end, [class*="btn-next-end"]');
                let hasBtnEnd = false;
                if (btnEnd) {
                    try { hasBtnEnd = DOMUtils.isVisible(btnEnd); } catch (_) { hasBtnEnd = true; }
                }
                const result = GraphicJsAdapter.completeCourse(d, 1000);
                return { ok: result.ok || hasBtnEnd, reason: 'reciprocal-' + (result.reason || '') };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // --- 7. 新版 item.js 答题页（.page-aqNN / .page-atNN / .page-afNN）JS 优先操作 ---
        // 新版典型结构：
        //   $(document).ready 内：
        //     $(".btn-at").each(idx => $(this).click(() => {
        //          atsum = idx + 1;
        //          if (atsum >= 4) → remove page-at04 / add page-2 / setTimeout clickP2.play();
        //          else → $(".page-aq0" + (atsum+1)).addClass("page-active").siblings().removeClass("page-active")
        //                  + $("input").prop("checked", false);
        //     $(".btn-af").each(idx => $(this).click(() => {
        //          $("input").prop("checked", false);
        //          $(".page-aq0"+(idx+1)).addClass.siblings.removeClass
        //     slFn(btn, radio, at, af, arrItem)
        //          → label click 时 $(radio).each push $(this).val() 到 arr
        //          → arr.uniq().sort().toString() === arrItem.sort().toString()  → at (答对)
        //          → else → af (答错) + clickError/clickSuccess 播放
        // 注意：btn-at/btn-af/slFn 都是 jQuery 绑定的 click 监听器，必须用 jQuery.trigger('click')
        //       才能进入站点 handler（不能只用原生 click()，因为 jQuery 事件不在原生冒泡里）。

        /** 当前活跃页是 .page-atNN（答对页）时，点击对应的 .btn-at 跳到下一题或跳出答题。
         * 用户新版 JS：
         *   $(".btn-at").each(function(index) {
         *     $(this).click(function() {
         *       clickBase.play();
         *       atsum = index + 1;
         *       if (atsum >= 4) {
         *         setWidth('.page-2')
         *         document.querySelector(".page-at04").classList.remove("page-active");
         *         document.querySelector(".page-2").classList.add("page-active");
         *         setTimeout(() => clickP2.play(), 500);
         *       } else {
         *         $(".page-aq0"+(atsum+1)).addClass("page-active").siblings().removeClass("page-active");
         *         $("input").prop("checked", false);
         *       }
         *     });
         *   });
         * 新增：.page-at04 后直接跳 .page-2，且附带 setWidth + clickP2 500ms 延迟。
         * 这里在 trigger('click') 成功后再做一层"兜底校验"：若 at04 没有真的跳到 page-2，就手动等价执行，
         * 避免因 btn-at 的 each 绑定顺序 / id 匹配失败卡在 at04 死循环。
         */
        static advanceAtPage(doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            if (!d || typeof d.querySelectorAll !== 'function') return { ok: false, reason: 'no-doc' };
            try {
                const activePage = GraphicJsAdapter.activePage(d);
                if (!activePage) return { ok: false, reason: 'no-active' };
                const cls = activePage.className || '';
                if (!/page-at\d+/.test(cls)) return { ok: false, reason: 'not-at-page' };

                const $ = GraphicJsAdapter._$(w);
                // 先播 clickBase（用户新版每个 btn-at click 都会播，按钮 trigger 不一定能走进闭包）
                try {
                    const clickBase = (w && w.clickBase) || (d.getElementById && d.getElementById('click-base'));
                    if (clickBase && typeof clickBase.play === 'function') try { clickBase.play(); } catch (_) {}
                } catch (_) {}

                let triggered = false;
                if ($ && typeof $ === 'function') {
                    const $at = $(activePage).find('.btn-at');
                    if ($at && $at.length) { $at.trigger('click'); triggered = true; }
                    else {
                        const $anyAt = $('.btn-at');
                        if ($anyAt && $anyAt.length) { $anyAt.first().trigger('click'); triggered = true; }
                    }
                }
                try {
                    const b = activePage.querySelector('.btn-at');
                    if (!triggered && b && typeof b.click === 'function') { b.click(); triggered = true; }
                } catch (_) {}

                // 关键修复：trigger 仅算"尝试"。必须同步校验当前活跃页是否变化：
                //   · 仍在当前 atNN → trigger 没生效（mock / 无监听） → 走手动等价实现
                //   · 不再 active → handler 生效，OK 直接返回
                const stillHere = () => {
                    try {
                        const cur = d.querySelector('.page-item.page-active');
                        return !!(cur && cur === activePage);
                    } catch (_) { return true; }
                };
                const switchedByTrigger = () => {
                    // 判断是否"真的切走了"：若仍在 atNN 则视为未切
                    return !stillHere();
                };

                const isAt04 = /(^|\s)page-at04(\s|$)/.test(cls);
                // at04：切到 page-2 + setWidth('.page-2') + 500ms clickP2.play()
                const doAt04Manual = () => {
                    try {
                        const stillAt04 = d.querySelector('.page-item.page-active.page-at04, .page-item.page-at04.page-active');
                        const page2 = d.querySelector('.page-2, [class*="page-2"].page-item');
                        if (page2 && !page2.classList.contains('page-active')) {
                            try {
                                if (stillAt04) stillAt04.classList.remove('page-active');
                                else if (activePage) activePage.classList.remove('page-active');
                            } catch (_) {}
                            try { page2.classList.add('page-active'); } catch (_) {}
                            try { GraphicJsAdapter.setWidth('.page-2', d); } catch (_) {}
                            try { if (w && typeof w.setWidth === 'function') w.setWidth('.page-2'); } catch (_) {}
                            try { if ($ && typeof $ === 'function') $(page2).addClass('page-active').siblings().removeClass('page-active'); } catch (_) {}
                        }
                        const clickP2 = (w && w.clickP2) || (d.getElementById && d.getElementById('click-p2'));
                        if (w && typeof w.setTimeout === 'function' && clickP2) {
                            w.setTimeout(() => { try { if (typeof clickP2.play === 'function') clickP2.play(); } catch (_) {} }, 500);
                        }
                        return true;
                    } catch (_) { return false; }
                };
                // 非 at04：按用户新版 atsum 计算 → $(".page-aq0"+(atsum+1)).addClass.siblings.removeClass + input.checked=false
                const doAtNxManual = () => {
                    try {
                        const m = cls.match(/page-at0?(\d+)/);
                        if (!m || !m[1]) return false;
                        const idx = parseInt(m[1], 10); // 1..3
                        const targetNum = idx + 1; // 2..4
                        const aqSel = `.page-aq${String(targetNum).padStart(2, '0')}, [class*="page-aq${String(targetNum).padStart(2, '0')}"]`;
                        const aqEl = d.querySelector(aqSel);
                        if (!aqEl) return false;
                        // 清除当前 active + 加新 active
                        try { if ($ && typeof $ === 'function') { $(aqEl).addClass('page-active').siblings().removeClass('page-active'); } } catch (_) {}
                        if (!aqEl.classList.contains('page-active')) {
                            const p = aqEl.parentNode;
                            if (p && p.querySelectorAll) p.querySelectorAll('.page-item.page-active').forEach(e => { try { e.classList.remove('page-active'); } catch (_) {} });
                            aqEl.classList.add('page-active');
                        }
                        // 清 input checked=false
                        try { if ($ && typeof $ === 'function') $('input').prop('checked', false); } catch (_) {}
                        return true;
                    } catch (_) { return false; }
                };

                if (switchedByTrigger()) {
                    // 已切成功：at04 补一下 setWidth + P2（避免站点 handler 只切 class 不播声音）
                    if (isAt04) {
                        try { GraphicJsAdapter.setWidth('.page-2', d); } catch (_) {}
                        const clickP2 = (w && w.clickP2) || (d.getElementById && d.getElementById('click-p2'));
                        if (w && typeof w.setTimeout === 'function' && clickP2) {
                            w.setTimeout(() => { try { if (typeof clickP2.play === 'function') clickP2.play(); } catch (_) {} }, 500);
                        }
                    }
                    return { ok: true, reason: triggered ? 'btn-at-triggered' : 'btn-at-fallback-exec', cls: cls, switched: 'trigger' };
                }

                // 未切：同步执行手动实现（不再用 setTimeout 0 延迟；离线/线上都会立刻推进一步）
                let manualDone = false;
                if (isAt04) {
                    manualDone = doAt04Manual();
                } else {
                    manualDone = doAtNxManual();
                    // 兜底清 input
                    try { if ($ && typeof $ === 'function') $('input').prop('checked', false); } catch (_) {}
                }

                return { ok: true, reason: triggered ? 'btn-at-triggered+manual' : 'btn-at-manual-only', cls: cls, manual: manualDone, switched: 'manual' };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        /** 当前活跃页是 .page-afNN（答错重来页）时，点击对应的 .btn-af 返回对应 .page-aqNN 重试。
         * 用户新版 JS：
         *   $(".btn-af").each(function(index) {
         *     $(this).click(function() {
         *       clickBase.play();
         *       $("input").prop("checked", false);
         *       $(".page-aq0"+(index+1)).addClass("page-active").siblings().removeClass("page-active");
         *     });
         *   });
         * 新增兜底：trigger 失败时按 page-afNN → page-aqNN 手动切，并统一 $("input").prop("checked", false) 清选项。
         */
        static advanceAfPage(doc) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            if (!d || typeof d.querySelectorAll !== 'function') return { ok: false, reason: 'no-doc' };
            try {
                const activePage = GraphicJsAdapter.activePage(d);
                if (!activePage) return { ok: false, reason: 'no-active' };
                const cls = activePage.className || '';
                if (!/page-af\d+/.test(cls)) return { ok: false, reason: 'not-af-page' };

                const $ = GraphicJsAdapter._$(w);
                // clickBase 音效 + input.checked=false（两个都在用户新版 handler 最前执行）
                try {
                    const clickBase = (w && w.clickBase) || (d.getElementById && d.getElementById('click-base'));
                    if (clickBase && typeof clickBase.play === 'function') try { clickBase.play(); } catch (_) {}
                } catch (_) {}
                try { if ($ && typeof $ === 'function') $('input').prop('checked', false); } catch (_) {}

                let triggered = false;
                if ($ && typeof $ === 'function') {
                    const $af = $(activePage).find('.btn-af');
                    if ($af && $af.length) { $af.trigger('click'); triggered = true; }
                    else {
                        const $anyAf = $('.btn-af');
                        if ($anyAf && $anyAf.length) { $anyAf.first().trigger('click'); triggered = true; }
                    }
                }
                try {
                    const b = activePage.querySelector('.btn-af');
                    if (!triggered && b && typeof b.click === 'function') { b.click(); triggered = true; }
                } catch (_) {}

                // 关键修复：trigger 后校验页面是否真的切换到了对应 aqNN
                const m = cls.match(/page-af(\d+)/);
                const num = (m && m[1]) ? m[1] : null;
                const aqNum = num ? (num.padStart ? num.padStart(2, '0') : num) : null;
                const aqSel = aqNum ? `.page-aq${aqNum}, [class*="page-aq${aqNum}"]` : null;
                const aqEl = aqSel ? d.querySelector(aqSel) : null;
                const reallySwitched = () => {
                    try {
                        // 两种成功：afNN 不再 active，或者 aqNN 已成为 active
                        if (aqEl && aqEl.classList && aqEl.classList.contains('page-active')) return true;
                        if (activePage && activePage.classList && !activePage.classList.contains('page-active')) return true;
                    } catch (_) {}
                    return false;
                };
                if (triggered && reallySwitched()) {
                    return { ok: true, reason: 'btn-af-triggered', cls: cls, switched: 'btn' };
                }

                // 兜底：没真切成功（不管是否 triggered 过按钮），按 afNN -> aqNN（同编号）手动切 class
                let manualDone = false;
                if (aqEl) {
                    if ($ && typeof $ === 'function') {
                        try { $(aqEl).addClass('page-active').siblings().removeClass('page-active'); manualDone = true; } catch (_) {}
                    }
                    if (!manualDone) {
                        const p = aqEl.parentNode;
                        if (p && p.querySelectorAll) p.querySelectorAll('.page-item.page-active').forEach(e => { try { e.classList.remove('page-active'); } catch (_) {} });
                        aqEl.classList.add('page-active');
                        manualDone = true;
                    }
                    // 与用户新版保持一致：input.prop("checked", false)
                    try { if ($ && typeof $ === 'function') $('input').prop('checked', false); } catch (_) {}
                }

                return { ok: true, reason: triggered ? 'btn-af-triggered+manual' : 'btn-af-class-fallback', cls: cls, switched: manualDone ? 'manual' : 'none', aq: aqNum };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        /**
         * 答题页（.page-aqNN）提交：按站点 slFn(btn, radio, at, af, arrItem) 逻辑，
         * 用 jQuery 触发"正确答案对应的 label"的点击 → slFn 自动比对、切页、播音效。
         *
         * 调用方需要从 handleQuizSelection 的结果里拿到 radioName(ai01~ai04) / correctAns([A])。
         * 本函数定位：$("input[name='${radioName}'][value='${correctAns}']") → 找其父级 <label> → trigger('click')。
         * 找不到 label 时，会 fallback 到"勾选 + 再尝试 advanceAtPage（极端情况）"。
         */
        static solveQuizSubmit(doc, radioName, correctAnswer, correctPageSel, wrongPageSel) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            if (!d || typeof d.querySelectorAll !== 'function') return { ok: false, reason: 'no-doc' };
            if (!radioName || !correctAnswer) return { ok: false, reason: 'bad-args' };
            try {
                const $ = GraphicJsAdapter._$(w);
                if (!$ || typeof $ !== 'function') return { ok: false, reason: 'no-jquery' };

                // 7a. 选 label：radioName 例如 ai01，正确答案 = A
                const selector = `input[name='${radioName}'][value='${correctAnswer}']`;
                const $radio = $(selector);
                let labelTriggered = false;

                if ($radio && $radio.length) {
                    // 新版 slFn(btn=label, radio, at, af, arrItem) 是监听 label 的 click
                    // → 从 radio 向上找 <label>（或其内部包含 label）
                    let $label = $radio.closest && $radio.closest('label');
                    if (!$label || !$label.length) {
                        try {
                            const rid = $radio.attr && $radio.attr('id');
                            if (rid) $label = $(`label[for="${rid}"]`);
                        } catch (_) {}
                    }
                    if (!$label || !$label.length) {
                        // fallback：radio 父级 .quiz-options 内所有 label（新版 slFn 的 btn 通常是 label 选择器）
                        $label = $radio.parents('.page-aq').first().find('label');
                    }
                    if ($label && $label.length) {
                        // 关键：jQuery 的 $label.trigger('click') 是合成事件，不会执行浏览器原生默认行为
                        // （label → 勾选关联 radio），而新版 slFn 依赖 `input[name='ai01']:checked` 判定。
                        // 因此先确保正确答案 radio 被勾选，再触发 label click，slFn 才能读到已勾选值进行比对。
                        try { $radio.prop('checked', true); } catch (_) {}
                        // 主路径：radio 原生 click（默认勾选 + 事件冒泡到 label → 触发 slFn 的 jQuery 监听）
                        try {
                            const radioEl = $radio[0];
                            if (radioEl && typeof radioEl.click === 'function') { radioEl.click(); }
                        } catch (_) {}
                        // 兜底：label jQuery trigger（slFn 幂等，重复触发无副作用）
                        $label.trigger('click');
                        labelTriggered = true;
                    } else {
                        // 无 label：手动 radio.prop('checked',true) 再兜底 trigger 一下 radio click
                        try {
                            $radio.prop('checked', true);
                            $radio.trigger('click');
                        } catch (_) {}
                    }
                }

                // 7b. 兜底：若 labelTriggered 没成功，但调用方给出正确/错误页，直接 class 切换模拟 slFn 行为
                if (!labelTriggered && (correctPageSel || wrongPageSel)) {
                    const $ = GraphicJsAdapter._$(w);
                    try {
                        if (correctPageSel && $) {
                            const $correct = $(correctPageSel);
                            if ($correct && $correct.length) {
                                $correct.addClass('page-active').siblings().removeClass('page-active');
                                return { ok: true, reason: 'fallback-class-correct', selector: selector };
                            }
                        }
                        if (wrongPageSel && $) {
                            const $wrong = $(wrongPageSel);
                            if ($wrong && $wrong.length) {
                                $wrong.addClass('page-active').siblings().removeClass('page-active');
                                return { ok: true, reason: 'fallback-class-wrong', selector: selector };
                            }
                        }
                    } catch (_) {}
                }

                return { ok: labelTriggered, reason: labelTriggered ? 'slFn-label-triggered' : 'no-label-or-radio' };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }

        // ====== 接口答案答题（mercuryprovider/listQuestion 的 isCorrect 一次答对，避免猜题触发风控） ======
        static _utf16to8(str) {
            let out = '', i, c;
            const len = str.length;
            for (i = 0; i < len; i++) {
                c = str.charCodeAt(i);
                if (c >= 0x0001 && c <= 0x007f) out += str.charAt(i);
                else if (c > 0x07ff) {
                    out += String.fromCharCode(0xe0 | ((c >> 12) & 0x0f));
                    out += String.fromCharCode(0x80 | ((c >> 6) & 0x3f));
                    out += String.fromCharCode(0x80 | ((c >> 0) & 0x3f));
                } else {
                    out += String.fromCharCode(0xc0 | ((c >> 6) & 0x1f));
                    out += String.fromCharCode(0x80 | ((c >> 0) & 0x3f));
                }
            }
            return out;
        }
        static _hexSha1(s) {
            const rol = (n, c) => (n << c) | (n >>> (32 - c));
            const safeAdd = (x, y) => { const lsw = (x & 0xffff) + (y & 0xffff); const msw = (x >> 16) + (y >> 16) + (lsw >> 16); return (msw << 16) | (lsw & 0xffff); };
            const ft = (t, b, c, d) => t < 20 ? ((b & c) | (~b & d)) : t < 40 ? (b ^ c ^ d) : t < 60 ? ((b & c) | (b & d) | (c & d)) : (b ^ c ^ d);
            const kt = (t) => t < 20 ? 1518500249 : t < 40 ? 1859775393 : t < 60 ? -1894007588 : -899497514;
            const nblk = ((s.length + 8) >> 6) + 1;
            const blks = new Array(nblk * 16);
            for (let i = 0; i < nblk * 16; i++) blks[i] = 0;
            for (let i = 0; i < s.length; i++) blks[i >> 2] |= s.charCodeAt(i) << (24 - (i & 3) * 8);
            blks[s.length >> 2] |= 0x80 << (24 - (s.length & 3) * 8);
            blks[nblk * 16 - 1] = s.length * 8;
            const w = new Array(80);
            let a = 1732584193, b = -271733879, c = -1732584194, d = 271733878, e = -1009589776;
            for (let i = 0; i < blks.length; i += 16) {
                const olda = a, oldb = b, oldc = c, oldd = d, olde = e;
                for (let j = 0; j < 80; j++) {
                    if (j < 16) w[j] = blks[i + j];
                    else w[j] = rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
                    const t = safeAdd(safeAdd(rol(a, 5), ft(j, b, c, d)), safeAdd(safeAdd(e, w[j]), kt(j)));
                    e = d; d = c; c = rol(b, 30); b = a; a = t;
                }
                a = safeAdd(a, olda); b = safeAdd(b, oldb); c = safeAdd(c, oldc); d = safeAdd(d, oldd); e = safeAdd(e, olde);
            }
            const bin = [a, b, c, d, e];
            const hex_tab = '0123456789abcdef';
            let str = '';
            for (let i = 0; i < bin.length * 4; i++) {
                str += hex_tab.charAt((bin[i >> 2] >> ((3 - (i % 4)) * 8 + 4)) & 0xf) + hex_tab.charAt((bin[i >> 2] >> ((3 - (i % 4)) * 8)) & 0xf);
            }
            return str.toUpperCase();
        }
        // mercuryprovider 签名：createSign(params, keyType) —— ropsign + SHA1(utf16to8)，与站点 JS 一致
        static _signParams(params, keyType) {
            try {
                const keys = Object.keys(params);
                const hashMap = [];
                keys.forEach((key) => {
                    if (params[key] || params[key] === 0) hashMap.push({ key, value: (params[key] !== 0 && !params[key]) ? '' : params[key] });
                });
                hashMap.sort((o, p) => o.key < p.key ? -1 : o.key > p.key ? 1 : 0);
                const secretKey = keyType === 1 ? '52c203760cf28798a44f6ac4' : keyType === 2 ? '75uet0kwvnc90xo' : 'bS7gH2jNpE4zRcF1mqwGt9s';
                let sss = secretKey;
                hashMap.forEach((it) => { sss += it.key + it.value; });
                sss += secretKey;
                return GraphicJsAdapter._hexSha1(GraphicJsAdapter._utf16to8(sss));
            } catch (_) { return ''; }
        }
        // 预取课程答题答案：listQuestion 返回 optionList.isCorrect（1=正确），option.id 与 DOM input.value 精确对应
        static async fetchQuizAnswers(courseId) {
            try {
                if (typeof State !== 'undefined') {
                    if (State._quizAnswerMap) return State._quizAnswerMap;
                    if (State._quizAnswersTried) return null;
                    if (State._quizAnswersLoading) return null;
                }
                if (!courseId) {
                    try { courseId = GraphicJsAdapter._qs('courseId', GraphicJsAdapter._pageWin()); } catch (_) {}
                }
                if (!courseId) return null;
                if (typeof State !== 'undefined') State._quizAnswersLoading = true;
                const signParams = {
                    appKey: '00000001', format: 'json', v: '1.0', timestamp: (Date.now() / 1000),
                    clientId: 'pharos', service: 'mercury.microlecture.listQuestion', id: courseId,
                };
                const sign = GraphicJsAdapter._signParams(signParams, 2);
                const body = Object.keys(signParams).map((k) => k + '=' + encodeURIComponent(signParams[k])).join('&') + '&sign=' + sign;
                const headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
                try {
                    if (typeof DataBridge !== 'undefined' && typeof DataBridge.getAuthToken === 'function') {
                        const tk = DataBridge.getAuthToken();
                        if (tk) headers['X-Token'] = tk;
                    }
                } catch (_) {}
                const resp = await HttpUtil.request('https://resource.mycourse.cn/mercuryprovider/router', {
                    method: 'POST', headers, body, timeout: 8000,
                });
                const text = await resp.text();
                const data = SafeJSON.parse(text, null);
                const d = (data && data.data) || null;
                if (data && String(data.code) === '0' && d) {
                    const map = {};
                    let idx = 0;
                    const lists = [(d.examQuestionList || []), (d.viewpointQuestionList || [])];
                    for (const list of lists) {
                        for (const q of (list || [])) {
                            const correctIds = (q.optionList || []).filter((o) => String(o.isCorrect) === '1').map((o) => String(o.id));
                            map[idx] = { type: q.type || 1, title: q.title || '', correctIds: correctIds };
                            idx++;
                        }
                    }
                    if (typeof State !== 'undefined') { State._quizAnswerMap = map; State._quizAnswersLoading = false; }
                    try { Logger.info(`[答题答案] 已获取 ${Object.keys(map).length} 题正确答案（listQuestion）`); } catch (_) {}
                    return map;
                }
                if (typeof State !== 'undefined') { State._quizAnswersLoading = false; State._quizAnswersTried = true; }
                return null;
            } catch (e) {
                try { if (typeof State !== 'undefined') { State._quizAnswersLoading = false; State._quizAnswersTried = true; } } catch (_) {}
                return null;
            }
        }
        // 按接口答案（option.id 列表）勾选并提交：多选全勾、单选勾一，一次答对避免猜题
        static solveQuizSubmitOptions(doc, radioName, correctOptionIds, correctPageSel, wrongPageSel) {
            const d = doc || GraphicJsAdapter._pageDoc();
            const w = GraphicJsAdapter._pageWin();
            if (!d || typeof d.querySelectorAll !== 'function') return { ok: false, reason: 'no-doc' };
            if (!radioName || !correctOptionIds || !correctOptionIds.length) return { ok: false, reason: 'bad-args' };
            try {
                const $ = GraphicJsAdapter._$(w);
                if (!$ || typeof $ !== 'function') return { ok: false, reason: 'no-jquery' };
                let firstLabel = null, checked = 0;
                const isCheckbox = (function () {
                    try { const f = d.querySelector(`input[name='${radioName}']`); return !!(f && f.type === 'checkbox'); } catch (_) { return false; }
                })();
                for (const optId of correctOptionIds) {
                    const sel = `input[name='${radioName}'][value='${optId}']`;
                    const $r = $(sel);
                    if ($r && $r.length) {
                        try { $r.prop('checked', true); } catch (_) {}
                        // radio：原生 click（默认选中 + 冒泡到 label 触发 slFn）。
                        // checkbox：禁止 el.click()——click 会 toggle 取消勾选（prop checked 后被 click 又变未勾）！
                        if (!isCheckbox) {
                            try {
                                const el = $r[0];
                                if (el && typeof el.click === 'function') { el.click(); }
                            } catch (_) {}
                        }
                        let $lbl = $r.closest && $r.closest('label');
                        if (!$lbl || !$lbl.length) { try { const rid = $r.attr && $r.attr('id'); if (rid) $lbl = $(`label[for="${rid}"]`); } catch (_) {} }
                        if ($lbl && $lbl.length && !firstLabel) firstLabel = $lbl;
                        checked++;
                    }
                }
                if (!checked) {
                    if (correctPageSel && $) {
                        const $c = $(correctPageSel);
                        if ($c && $c.length) { $c.addClass('page-active').siblings().removeClass('page-active'); return { ok: true, reason: 'fallback-class-correct' }; }
                    }
                    return { ok: false, reason: 'no-option-found' };
                }
                // 触发首个 label click（slFn 读所有 checked 判对/错）
                if (firstLabel && firstLabel.length) {
                    try { firstLabel.trigger('click'); } catch (_) {}
                    // checkbox：label click 会 toggle 关联 input 取消勾选 → 触发后统一勾回
                    if (isCheckbox) {
                        for (const optId of correctOptionIds) {
                            try {
                                const el = d.querySelector(`input[name='${radioName}'][value='${optId}']`);
                                if (el) el.checked = true;
                            } catch (_) {}
                        }
                    }
                    try { if (firstLabel[0] && typeof firstLabel[0].click === 'function') firstLabel[0].click(); } catch (_) {}
                } else {
                    try { $(`input[name='${radioName}']`).trigger('change'); } catch (_) {}
                }
                return { ok: true, reason: 'interface-answer-submit', checked: checked };
            } catch (e) { return { ok: false, reason: 'error:' + (e && e.message || '') }; }
        }
    }

    class ShuaKeController {
        constructor() {
            console.log('[ShuaKeController] 构造函数开始');
            try {
                this.loopTimer = null;
                this.statsTimer = null;
                this.injectKey = null;
                this.injectKeyConfirmed = false;
                this.panel = null;
                this.isIframe = (typeof window !== 'undefined') && (window.self !== window.top);
                this.injectRetryTimer = null;
                this.pendingInject = false;
                this.injectRetryCount = 0;
                this.maxInjectRetry = 5;
                this.injectRetries = 0;
                this.mutationObserver = null;
                this._pageWatchStop = null;  // DOMWatcher 的取消函数
                this._keyboardHandler = null;
                this._messageHandler = null;
                this._iframeCheckInterval = null;
                this._alertInterval = null;
                this._running = true;  // 内部停止标记
                this._lastStatusText = null;   // sendStatus 去重缓存
                this._lastStatusClass = null;
                this._lastProgress = null;     // sendProgress 去重缓存
                this._lastGraphicLog = false;  // "进入图文处理逻辑" 日志去重

                console.log('[ShuaKeController] 开始调用 init()');
                this._initPromise = this.init();
                console.log('[ShuaKeController] 开始调用 initKeyboardShortcuts()');
                this.initKeyboardShortcuts();
                console.log('[ShuaKeController] 开始调用 installAjaxHook()');
                this.installAjaxHook();
                console.log('[ShuaKeController] 构造函数完成');
            } catch (e) {
                console.error('[ShuaKeController] 构造函数异常:', e);
                throw e;
            }
        }

        // 安装 ajax-hook（在构造时调用一次）
        installAjaxHook() {
            try {
                if (!AjaxHooker.install()) return;
                AjaxHooker.installFetch();

                // 1) 自动捕获 token：监听 pharos 系列 API 请求
                AjaxHooker.on(/pharos\/(usercourse|project|studyassistant)/, (phase, config, body) => {
                    if (phase === 'request') {
                        const token = AjaxHooker.getToken('x-token');
                        if (token) {
                            window.__authToken = token;
                            try { Logger.debug(`通过 ajax-hook 捕获 x-token`); } catch (_) {}
                        }
                    }
                });

                // 2) 监听课程完成上报（study/process.do 等）
                AjaxHooker.on(/study.*process|complete.*course/i, (phase, config, body) => {
                    if (phase === 'response' && body) {
                        try { Logger.debug(`课程进度上报: ${JSON.stringify(body).substring(0, 200)}`); } catch (_) {}
                    }
                });

                // 3) 数据窃听（共享函数；库加载前预安装若已注册，此处同 pattern 覆盖，幂等）
                registerDataEavesdrop();
            } catch (e) {
                try { Logger.debug(`installAjaxHook 异常: ${e.message}`); } catch (_) {}
            }
        }

        // 初始化快捷键
        initKeyboardShortcuts() {
            this._keyboardHandler = (e) => {
                try {
                    if (!e || !e.target) return;
                    // 忽略输入框内的按键
                    const tag = e.target.tagName;
                    if (tag === 'INPUT' || tag === 'TEXTAREA' || e.target.isContentEditable) return;

                    const key = (e.key || '').toLowerCase();
                    switch(key) {
                        case 'p':
                            if (State.isPaused) {
                                this.resume();
                                try { showFloatToast('▶ 继续刷课', 'success'); } catch (_) {}
                            } else {
                                this.pause();
                                try { showFloatToast('⏸ 已暂停刷课', 'warning'); } catch (_) {}
                            }
                            e.preventDefault();
                            break;
                        case 's':
                            this.stop();
                            try { showFloatToast('⏹ 已停止刷课', 'danger'); } catch (_) {}
                            e.preventDefault();
                            break;
                        case 'd':
                            CONFIG.debugMode = !CONFIG.debugMode;
                            ConfigManager.save();
                            Logger.info(`调试模式: ${CONFIG.debugMode ? '开启' : '关闭'}`);
                            try { showFloatToast(`🛠 调试模式: ${CONFIG.debugMode ? '开启' : '关闭'}`, CONFIG.debugMode ? 'success' : 'info'); } catch (_) {}
                            this.panel?.updateDebugMode();
                            this.panel?._updateDebugBadge?.();
                            break;
                        case 'm':
                            // 最小化 / 展开面板
                            if (this.panel) {
                                const wasMin = !!(this.panel._state && this.panel._state.minimized);
                                this.panel.toggle();
                                try { showFloatToast(wasMin ? '🔍 面板已展开' : '📉 面板已最小化', 'info'); } catch (_) {}
                            }
                            e.preventDefault();
                            break;
                        case 'k':
                            // 切换面板显示 / 隐藏
                            if (this.panel) {
                                const willHide = this.panel.style.display !== 'none';
                                this.panel.toggleVisible();
                                try { showFloatToast(willHide ? '🙈 面板已隐藏 (K 显示)' : '👀 面板已显示 (K 隐藏)', 'info'); } catch (_) {}
                            }
                            e.preventDefault();
                            break;
                        case 'h':
                            if (this.panel) {
                                this.panel.toggle();
                            }
                            e.preventDefault();
                            break;
                        case 'l':
                            try {
                                const c = document.getElementById('shuake-logs-container');
                                if (c) c.innerHTML = '<div class="shuake-log-empty">日志已清空</div>';
                                ShuaKeUI.toast('日志已清空', 'secondary', 1200);
                                try { showFloatToast('🧹 日志已清空', 'success'); } catch (_) {}
                            } catch (_) {}
                            e.preventDefault();
                            break;
                        case 'r':
                            // 刷新项目数据（课程/任务/考试）
                            try {
                                if (this.panel && typeof this.panel.refreshProjectData === 'function') {
                                    this.panel.refreshProjectData();
                                    try { showFloatToast('🔄 正在刷新项目数据', 'info'); } catch (_) {}
                                }
                            } catch (_) {}
                            e.preventDefault();
                            break;
                        case 'a':
                            // AI 答题开关
                            try {
                                const next = !CONFIG.enableAIAnswer;
                                if (this.panel && typeof this.panel.onAIAnswerChange === 'function') {
                                    this.panel.onAIAnswerChange(next);
                                } else {
                                    CONFIG.enableAIAnswer = next;
                                    ConfigManager.save();
                                }
                                try { showFloatToast(`🤖 AI 答题: ${next ? '开启' : '关闭'}`, next ? 'success' : 'info'); } catch (_) {}
                            } catch (_) {}
                            e.preventDefault();
                            break;
                        case 't':
                            // 测试 AI 连接
                            try {
                                if (this.panel && typeof this.panel.testAI === 'function') {
                                    this.panel.testAI();
                                    try { showFloatToast('🧪 正在测试 AI 连接...', 'info'); } catch (_) {}
                                }
                            } catch (_) {}
                            e.preventDefault();
                            break;
                        case '?':
                        case '/':
                            try {
                                const help = '麦课刷课助手快捷键\nP 暂停/继续\nS 停止刷课\nD 调试模式\nM 最小化/展开面板\nK 切换面板显示\nL 清空日志\nR 刷新项目数据\nA AI 答题开关\nT 测试 AI 连接\n? 帮助';
                                try { showFloatToast(help, 'info', 4000); } catch (_) {}
                            } catch (_) {}
                            e.preventDefault();
                            break;
                    }
                } catch (err) {
                    try { Logger.debug(`快捷键异常: ${err.message}`); } catch (_) {}
                }
            };
            document.addEventListener('keydown', this._keyboardHandler);
            Logger.debug('快捷键已启用: P=暂停 S=停止 D=调试 M/H/K=面板 L=清空日志 R=刷新 A=AI开关 T=测试AI ?=帮助');
        }

        async init() {
            try {
                this.isMcwkDirect = (location.hostname || '').includes('mcwk.mycourse.cn');

                // 【版本检测·启动期】fire-and-forget：网络失败静默，绝不阻塞主流程。
                // 有更新 → 右下角角标；强制更新 → confirm 引导 + GM_setValue('forceUpdateRequired')。
                try { if (typeof VersionChecker !== 'undefined' && typeof VersionChecker.autoCheck === 'function') VersionChecker.autoCheck(); } catch (_) {}

                // 【运行状态持久化】恢复暂停/停止/开始状态，防止页面更新/刷新丢失工具栏按钮设置。
                // 无持久化记录（首次/旧版升级）默认 isRunning=false：不自动刷课，需面板点"开始刷课"。
                try {
                    const rs = gmReadJSON('shuake_run_state', {});
                    if (rs && typeof rs === 'object') {
                        if (rs.isPaused === true) State.isPaused = true;
                        if (typeof rs.isRunning === 'boolean') State.isRunning = rs.isRunning;
                        try { Logger.info(`已恢复运行状态: ${State.isRunning ? '运行中' : '（未开始，点"开始刷课"启动）'}${State.isPaused ? '（已暂停）' : ''}`); } catch (_) {}
                    }
                } catch (_) {}

                if (this.isMcwkDirect) {
                    this.initMcwkDirect();
                } else if (this.isIframe) {
                    this.initIframe();
                } else {
                    this.initTop();
                }
            } catch (e) {
                try { Logger.error(`init 异常: ${e.message}`); } catch (_) {}
            }
        }

        // mcwk.mycourse.cn 直接访问模式
        initMcwkDirect() {
            try {
                Logger.info('mcwk 直接模式初始化');

                // 立即拦截 alert
                window.alert = function(msg) {
                    try { Logger.debug(`拦截 alert: ${msg}`); } catch (_) {}
                };

                // 等待 VideoJS 初始化（限制尝试次数）
                let mcwkWaitCount = 0;
                const maxMcwkWait = 30;  // 30 * 300ms = 9s
                const waitForVideoJS = safeInterval(() => {
                    mcwkWaitCount++;
                    if (window.videojs) {
                        clearInterval(waitForVideoJS);
                        this.startWatch();
                        this.registerVideoEvents();
                        Logger.debug('VideoJS 已就绪');
                    } else if (mcwkWaitCount >= maxMcwkWait) {
                        clearInterval(waitForVideoJS);
                        Logger.debug('VideoJS 等待超时，强制启动');
                        this.startWatch();
                    }
                }, 300);

                // 10秒超时后强制启动（兜底）
                setTimeout(() => {
                    clearInterval(waitForVideoJS);
                    this.startWatch();
                }, 10000);
            } catch (e) {
                try { Logger.debug(`initMcwkDirect 异常: ${e.message}`); } catch (_) {}
            }
        }

        // 顶层窗口初始化
        initTop() {
            try {
                Logger.info('麦课刷课助手启动');

                this.injectKey = `est_${Date.now()}`;

                // 获取课程信息
                CourseInfo.fetchDetails().then(info => {
                    try {
                        if (!info) {
                            CourseInfo.getFromDOM();
                            info = CourseInfo.data;
                        }
                        if (info) {
                            State.currentCourseName = info.name || info.courseName;
                            Logger.info(`当前课程: ${State.currentCourseName}`);
                        }
                        this.panel?.updateCourseInfo(CourseInfo.getDisplayInfo());
                    } catch (e) {
                        try { Logger.debug(`课程信息回调异常: ${e.message}`); } catch (_) {}
                    }
                }).catch(e => {
                    try { Logger.debug(`获取课程信息失败: ${e?.message || e}`); } catch (_) {}
                });

                // 仅在有 userProjectId 时获取项目进度和分类信息
                // 兼容 weiban SPA hash 路由（#/course/detail?userProjectId=...）与 mcwk query 路由，
                // 以及列表页 projectId 别名（#/course?projectId=...）+ 持久化身份
                let hasProjectId = false;
                try {
                    const params = new URLSearchParams(window.location.search);
                    hasProjectId = params.get('userProjectId');
                    if (!hasProjectId) {
                        const hash = window.location.hash;
                        if (hash && hash.includes('userProjectId=')) {
                            try { hasProjectId = new URLSearchParams(hash.split('?')[1] || '').get('userProjectId'); } catch (_) {}
                        }
                    }
                    if (!hasProjectId) {
                        hasProjectId = params.get('projectId');
                        if (!hasProjectId) {
                            const hash = window.location.hash;
                            if (hash && hash.includes('projectId=')) {
                                try { hasProjectId = new URLSearchParams(hash.split('?')[1] || '').get('projectId'); } catch (_) {}
                            }
                        }
                    }
                    if (!hasProjectId) {
                        try { const si = StoredIdentity.load(); if (si && si.userProjectId) hasProjectId = si.userProjectId; } catch (_) {}
                    }
                } catch (_) {}

                if (hasProjectId) {
                    // 获取项目进度信息
                    ProjectInfo.fetchDetails().then(projectInfo => {
                        try {
                            if (projectInfo) {
                                this.panel?.updateProjectInfo(ProjectInfo.getDisplayInfo());
                                Logger.info(`项目进度: ${projectInfo.name}, ${projectInfo.requiredFinishedNum}/${projectInfo.requiredNum} 课程`);
                            }
                        } catch (e) {
                            try { Logger.debug(`项目信息回调异常: ${e.message}`); } catch (_) {}
                        }
                    }).catch(e => {
                        try { Logger.debug(`获取项目信息失败: ${e?.message || e}`); } catch (_) {}
                    });

                    // 获取课程分类信息
                    CategoryInfo.fetchDetails().then(categories => {
                        try {
                            if (categories && categories.length > 0) {
                                Logger.info(`获取到 ${categories.length} 个课程分类`);
                                CategoryInfo.fetchCoursesByCategory(categories[0].categoryCode).then(courses => {
                                    try {
                                        if (courses && courses.length > 0) {
                                            Logger.info(`当前分类 "${categories[0].categoryName}" 有 ${courses.length} 个课程`);
                                        }
                                    } catch (_) {}
                                }).catch(() => {});
                            }
                        } catch (e) {
                            try { Logger.debug(`课程分类回调异常: ${e.message}`); } catch (_) {}
                        }
                    }).catch(e => {
                        try { Logger.debug(`获取课程分类失败: ${e?.message || e}`); } catch (_) {}
                    });

                    // 获取考试列表（写入缓存；失败时回退缓存数据）
                    ExamManager.fetchList().then(() => {
                        try { this.panel?.refreshCoursePanel(); } catch (_) {}
                    }).catch(e => {
                        try { Logger.debug(`获取考试列表失败: ${e?.message || e}`); } catch (_) {}
                    });

                    // 获取学习助手场景提示
                    StudyAssistant.fetchScene().then(sceneData => {
                        try {
                            if (sceneData) {
                                const message = StudyAssistant.getPromptMessage();
                                if (message) {
                                    Logger.info(`📢 学习提示: ${message}`);
                                }
                                if (StudyAssistant.isAllCoursesCompleted()) {
                                    Logger.info('🎉 所有课程已完成，可以开始考试了！');
                                }
                            }
                        } catch (e) {
                            try { Logger.debug(`学习助手回调异常: ${e.message}`); } catch (_) {}
                        }
                    }).catch(e => {
                        try { Logger.debug(`获取学习助手失败: ${e?.message || e}`); } catch (_) {}
                    });
                }

                this._messageHandler = (event) => {
                    try {
                        // 验证消息来源（仅同源）
                        if (event && event.origin && event.origin !== 'null' && event.origin !== window.location.origin) {
                            // 跨域消息：只接受特定类型
                            if (!event.data || typeof event.data !== 'object') return;
                        }
                        const data = event?.data;
                        if (!data || typeof data !== 'object' || !data.type) return;

                        switch (data.type) {
                            case "needInjectKey":
                                if (event.source && typeof event.source.postMessage === 'function') {
                                    event.source.postMessage({
                                        type: "injectKeyResp",
                                        injectKey: this.injectKey,
                                        topReady: true
                                    }, "*");
                                    Logger.debug(`已发送 injectKey 给 iframe: ${this.injectKey}`);
                                }
                                break;
                            case "doInject":
                                if (data.key !== this.injectKey) {
                                    Logger.warning(`injectKey 不匹配: 收到 ${data.key}, 期望 ${this.injectKey}`);
                                    if (event.source && typeof event.source.postMessage === 'function') {
                                        event.source.postMessage({ type: "injectResult", success: false, error: 'key mismatch' }, "*");
                                    }
                                    return;
                                }
                                if (event.source && typeof event.source.postMessage === 'function') {
                                    event.source.postMessage({
                                        type: "injectForward",
                                        key: data.key
                                    }, "*");
                                }
                                break;
                            case "injectResult":
                                if (data.success) {
                                    Logger.success('课程完成已记录');
                                } else {
                                    Logger.warning(`课程完成记录失败: ${data.error || 'unknown'}`);
                                }
                                break;
                            case "logEntry":
                                if (data.entry) this.panel?.addLog(data.entry);
                                break;
                            case "statusUpdate":
                                if (typeof data.text === 'string') this.panel?.updateStatus(data.text, data.className);
                                break;
                            case "progressUpdate":
                                this.panel?.updateProgress(data.percent);
                                break;
                            case "courseInfoUpdate":
                                if (data.info && typeof data.info === 'object') {
                                    const existing = CourseInfo.data || {};
                                    CourseInfo.data = Object.assign({}, existing, {
                                        totalPage: data.info.totalPage,
                                        finishedPage: data.info.finishedPage,
                                        progress: data.info.progress
                                    });
                                    this.panel?.updateCourseInfo(CourseInfo.getDisplayInfo());
                                }
                                break;
                        }
                    } catch (e) {
                        try { Logger.debug(`顶层 message 处理异常: ${e.message}`); } catch (_) {}
                    }
                };
                window.addEventListener('message', this._messageHandler);

                // 启动检测循环（包含创建控制面板）
                this.startWatch();

                Logger.success('顶层脚本启动完成');
            } catch (e) {
                try { Logger.error(`initTop 异常: ${e.message}`); } catch (_) {}
            }
        }

        // 等待 iframe 就绪
        waitForIframe(callback) {
            const startTime = Date.now();
            const check = () => {
                const iframe = document.querySelector('.page-iframe, iframe[src*="mycourse"]');
                if (iframe && iframe.contentWindow) {
                    callback();
                    return;
                }
                if (Date.now() - startTime > 10000) {
                    Logger.warning('等待 iframe 超时 (10000ms)');
                    return;
                }
                setTimeout(check, 500);
            };
            check();
        }

        // 执行 inject（在 iframe 中调用）
        // 注意：顶层不执行 inject，由 iframe 自己执行
        doInject(key) {
            Logger.debug(`顶层收到 inject 请求: ${key}，转发给 iframe`);
            return true;
        }

        // iframe 子窗口初始化
        initIframe() {
            try {
                Logger.info('iframe 脚本初始化');

                this._messageHandler = (e) => {
                    try {
                        const d = e?.data;
                        if (!d || typeof d !== 'object' || !d.type) return;

                        if (d.type === "injectKeyResp") {
                            if (d.injectKey) {
                                this.injectKey = d.injectKey;
                                this.injectKeyConfirmed = true;
                                Logger.debug(`收到 injectKey: ${this.injectKey}, 顶层已就绪: ${d.topReady}`);
                            }
                        }
                        if (d.type === "injectResult") {
                            if (d.success) {
                                Logger.success('课程完成已记录');
                            } else {
                                Logger.warning(`课程完成记录失败: ${d.error || 'unknown'}`);
                                Logger.info('inject 多次失败，3秒后刷新页面...');
                                setTimeout(() => {
                                    try { location.reload(); } catch (_) {}
                                }, 3000);
                            }
                            this.pendingInject = false;
                            this.injectRetries = 0;
                        }
                        if (d.type === "injectForward") {
                            Logger.info('收到 inject 转发请求，执行中...');
                            this.doInjectInIframe();
                        }
                    } catch (err) {
                        try { Logger.debug(`iframe message 处理异常: ${err.message}`); } catch (_) {}
                    }
                };
                window.addEventListener('message', this._messageHandler);

                // 请求 injectKey
                try {
                    if (window.top && window.top !== window.self) {
                        window.top.postMessage({ type: "needInjectKey" }, "*");
                    }
                } catch (err) {
                    Logger.debug(`请求 injectKey 失败: ${err.message}`);
                }

                // 延迟启动检测
                setTimeout(() => {
                    try { this.startWatch(); } catch (e) {}
                }, 1000);

                // 如果一直没收到响应，5秒后也强制启动
                setTimeout(() => {
                    if (!this.injectKeyConfirmed) {
                        Logger.warning('未收到 injectKey 响应，使用备用方案');
                        this.injectKey = `backup_${Date.now()}`;
                        this.injectKeyConfirmed = true;
                    }
                }, 5000);
            } catch (e) {
                try { Logger.debug(`initIframe 异常: ${e.message}`); } catch (_) {}
            }
        }

        // 在 iframe 中执行 inject
        doInjectInIframe() {
            try {
                if (!window.est) {
                    Logger.warning('iframe 中 window.est 不存在，尝试等待...');
                    let waitTime = 0;
                    const maxWait = 3000;
                    const waitForEst = setInterval(() => {
                        try {
                            waitTime += 500;
                            if (window.est) {
                                clearInterval(waitForEst);
                                this.executeInject();
                            } else if (waitTime >= maxWait) {
                                clearInterval(waitForEst);
                                Logger.error('等待 window.est 超时');
                                this._postInjectResult(false, 'window.est not found after timeout');
                            }
                        } catch (e) {
                            clearInterval(waitForEst);
                            try { Logger.debug(`等待 est 异常: ${e.message}`); } catch (_) {}
                        }
                    }, 500);
                    return;
                }
                this.executeInject();
            } catch (e) {
                try { Logger.debug(`doInjectInIframe 异常: ${e.message}`); } catch (_) {}
                this._postInjectResult(false, e?.message || 'unknown');
            }
        }

        _postInjectResult(success, error) {
            try {
                if (window.top && window.top !== window.self) {
                    window.top.postMessage({
                        type: "injectResult",
                        success,
                        error
                    }, "*");
                }
            } catch (e) {}
        }

        executeInject() {
            try {
                const key = this.injectKey || `iframe_${Date.now()}`;
                if (!window.est || typeof window.est.inject !== 'function') {
                    Logger.error('est.inject 不存在或不可调用');
                    this._postInjectResult(false, 'est.inject unavailable');
                    return;
                }
                window.est.inject(key);
                Logger.success('est.inject 执行成功');
                this._postInjectResult(true);
            } catch (err) {
                Logger.error(`est.inject 执行异常: ${err.message}`);
                this._postInjectResult(false, err?.message || 'unknown');
            }
        }

        // 检测并处理图文内嵌入的视频
        handleEmbeddedVideo(doc = document) {
            try {
                if (!doc || typeof doc.querySelector !== 'function') return false;
                const activeSection = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (!activeSection) return false;

                const videoContainer = activeSection.querySelector('.xgplayer, #xgplayer, video');
                if (!videoContainer) return false;
                // 空 URL 播放器桩（新版图文模板 page-0 的 xgplayer Hlsplay('mse','')）不当作内嵌视频
                if (!activeSection.classList.contains('page-video') && !GraphicAdapter.hasRealVideoSource(activeSection)) {
                    return false;
                }
                // 记录开始处理时间：用于 16139 视频页卡死超时判定（自动播放被拦截时视频永不完成）
                try { if (!State.videoPlayStartTime) State.videoPlayStartTime = Date.now(); } catch (_) {}

                let player = null;

                // 尝试获取 xgplayer 实例
                if (videoContainer.id && window.xgplayerMap) {
                    player = window.xgplayerMap[videoContainer.id];
                }

                // 如果有原生 video
                const video = activeSection.querySelector('video');
                if (video) {
                    try {
                        // 检查是否暂停
                        if (video.paused) {
                            const playBtn = activeSection.querySelector('.xgplayer-start, .xgplayer-play, .xgplayer-icon-play, video');
                            if (playBtn && playBtn.getAttribute('data-shuake-videoplayclicked') !== '1') {
                                try { playBtn.setAttribute('data-shuake-videoplayclicked', '1'); } catch (_) {}
                                Logger.info('点击图文内嵌视频播放按钮');
                                try { DOMUtils.simulateClick(playBtn); } catch (e) {}
                                return true;
                            }
                            video.play().catch(() => {});
                            // 自动播放被浏览器拦截（play() rejected）时 video 会一直暂停：
                            // 只要有 duration 就直接快进到末尾，触发站点 timeupdate 自动切页
                            // （站点逻辑：currentTime >= duration - 1.5 → $(".page-1").addClass("page-active")）。
                            if (!video.ended && video.duration > 2 && video.currentTime < video.duration - 1) {
                                try { video.currentTime = video.duration - 1; } catch (_) {}
                                try { Logger.debug(`自动播放被拦截，强制快进到 ${Math.floor(video.duration - 1)}s`); } catch (_) {}
                            }
                            return true;
                        }

                        // 检查是否播放完成
                        if (!video.ended && video.currentTime < (video.duration || 0) - 1) {
                            if (CONFIG.realVideoPlay) {
                                // 真实视频播放模式：真实播放，不跳进度，等待自然播放完成
                                const vRate = CONFIG.videoPlaybackRate > 0 ? CONFIG.videoPlaybackRate : 2;
                                Logger.debug(`图文内嵌视频 ${vRate}x 播放中: ${Math.floor(video.currentTime)}/${Math.floor(video.duration)}`);
                                try { if (video.playbackRate !== vRate) video.playbackRate = vRate; } catch (_) {}
                            } else {
                                Logger.debug(`图文内嵌视频播放中: ${Math.floor(video.currentTime)}/${Math.floor(video.duration)}`);
                                if (video.duration > 2) {
                                    video.currentTime = video.duration - 1;
                                    Logger.debug(`强制跳转视频进度到 ${Math.floor(video.duration - 1)}s`);
                                }
                            }
                            return true;
                        }

                        // 视频已播放完或接近结尾
                        if (video.ended || (video.duration > 0 && video.currentTime >= video.duration - 2)) {
                            Logger.success('图文内嵌视频播放完成');
                            // 若翻页中（已点击过）不再重复触发
                            if (State.isPageTurning) {
                                return true;
                            }
                            const nextBtn = GraphicAdapter.findNextIn(activeSection);
                            if (nextBtn) {
                                Logger.info('点击视频完成后的下一页按钮');
                                if (nextBtn.tagName === 'IMG') {
                                    const parent = nextBtn.closest('a, button, div[onclick], [role="button"]');
                                    try { DOMUtils.simulateClick(parent || nextBtn); } catch (e) {}
                                } else {
                                    try { DOMUtils.simulateClick(nextBtn); } catch (e) {}
                                }
                                State.videoCompleted = true;
                                GraphicAdapter.markPageTurnTriggered('handleEmbeddedVideo:next');
                                return true;
                            }
                            State.videoCompleted = true;
                            return false;
                        }
                    } catch (e) {
                        try { Logger.debug(`处理原生 video 异常: ${e.message}`); } catch (_) {}
                    }
                    return true;
                }

                // 处理 xgplayer
                if (player || activeSection.querySelector('.xgplayer')) {
                    Logger.info('检测到图文内嵌 xgplayer 视频');

                    if (!player) {
                        try {
                            const playerEl = activeSection.querySelector('.xgplayer');
                            if (playerEl && playerEl.id && window.xgplayerMap) {
                                player = window.xgplayerMap[playerEl.id];
                            }
                            if (!player) {
                                const domVideo = activeSection.querySelector('.xgplayer video');
                                if (domVideo) {
                                    const current = domVideo.currentTime || 0;
                                    const duration = domVideo.duration || 0;
                                    if (duration > 0) {
                                        Logger.debug(`xgplayer DOM 视频: ${Math.floor(current)}/${Math.floor(duration)}`);
                                        if (current >= duration - 2) {
                                            Logger.success('图文内嵌视频(DOM)播放完成');
                                            if (State.isPageTurning) {
                                                return true;
                                            }
                                            const nextBtn = GraphicAdapter.findNextIn(activeSection);
                                            if (nextBtn) {
                                                Logger.info('点击视频完成后的下一页按钮');
                                                if (nextBtn.tagName === 'IMG') {
                                                    const parent = nextBtn.closest('a, button, div[onclick], [role="button"]');
                                                    try { DOMUtils.simulateClick(parent || nextBtn); } catch (e) {}
                                                } else {
                                                    try { DOMUtils.simulateClick(nextBtn); } catch (e) {}
                                                }
                                                State.videoCompleted = true;
                                                GraphicAdapter.markPageTurnTriggered('handleEmbeddedVideo:next:dom');
                                                return true;
                                            }
                                            State.videoCompleted = true;
                                            return false;
                                        }
                                        domVideo.currentTime = duration - 1;
                                        const startBtn = activeSection.querySelector('.xgplayer-start, .xgplayer-icon-play');
                                        if (startBtn && startBtn.getAttribute('data-shuake-videoplayclicked') !== '1') {
                                            try { startBtn.setAttribute('data-shuake-videoplayclicked', '1'); } catch (_) {}
                                            try { DOMUtils.simulateClick(startBtn); } catch (e) {}
                                        }
                                        return true;
                                    }
                                }
                            }
                        } catch (e) {
                            try { Logger.debug(`xgplayer DOM 处理异常: ${e.message}`); } catch (_) {}
                        }
                    }

                    if (player) {
                        try {
                            if (!player.videoEl || player.videoEl.paused) {
                                Logger.debug('尝试播放 xgplayer');
                                if (typeof player.play === 'function') {
                                    // 自动播放被浏览器拦截时会返回 rejected promise，必须 catch，否则报"未处理 Promise 异常"
                                    try { player.play().catch(() => {}); } catch (e) {}
                                }
                            }

                            const currentTime = player.currentTime || 0;
                            const duration = player.duration || 0;

                            if (duration > 0 && currentTime >= duration - 3) {
                                Logger.success('图文内嵌视频播放完成');
                                if (State.isPageTurning) {
                                    return true;
                                }
                                const nextBtn = GraphicAdapter.findNextIn(activeSection);
                                if (nextBtn) {
                                    Logger.info('点击视频完成后的下一页按钮');
                                    if (nextBtn.tagName === 'IMG') {
                                        const parent = nextBtn.closest('a, button, div[onclick], [role="button"]');
                                        try { DOMUtils.simulateClick(parent || nextBtn); } catch (e) {}
                                    } else {
                                        try { DOMUtils.simulateClick(nextBtn); } catch (e) {}
                                    }
                                    State.videoCompleted = true;
                                    GraphicAdapter.markPageTurnTriggered('handleEmbeddedVideo:next:xgp');
                                    return true;
                                }
                                State.videoCompleted = true;
                                return false;
                            }

                            if (duration > 0 && currentTime < duration - 5) {
                                try { player.currentTime = duration - 2; } catch (e) {}
                                Logger.debug(`xgplayer 跳转: ${Math.floor(currentTime)}s -> ${Math.floor(duration - 2)}s`);
                            }
                        } catch (e) {
                            try { Logger.debug(`处理 xgplayer 异常: ${e.message}`); } catch (_) {}
                        }
                        return true;
                    } else {
                        const startBtn = activeSection.querySelector('.xgplayer-start, .xgplayer-icon-play');
                        if (startBtn && startBtn.getAttribute('data-shuake-videoplayclicked') !== '1') {
                            try { startBtn.setAttribute('data-shuake-videoplayclicked', '1'); } catch (_) {}
                            Logger.info('点击 xgplayer 开始/播放按钮');
                            try { DOMUtils.simulateClick(startBtn); } catch (e) {}
                            return true;
                        }
                    }
                }
            } catch (e) {
                try { Logger.debug(`handleEmbeddedVideo 异常: ${e.message}`); } catch (_) {}
            }
            return false;
        }

        // 检测课程列表页 URL
        detectCourseListUrl() {
            try {
                const top = (window.top && window.top.location) ? window.top : window;
                const hash = top.location.hash || '';
                if (hash) return top.location.href;
            } catch (e) {}
            return 'https://weiban.mycourse.cn/';
        }

        // 接口驱动：根据 listCourse 接口返回的未完成课程，自动进入下一课刷课
        async autoAdvanceByAPI() {
            if (this._autoAdvancing) return false;
            this._autoAdvancing = true;
            try {
                const courses = await StudyAssistant.fetchCourses();
                if (!courses || courses.length === 0) return false;
                State.allCourses = courses;
                const pending = StudyAssistant.getPendingCourses();
                State.pendingCourses = pending;
                try { window.shuakePanelInstance?.refreshCoursePanel(); } catch (_) {}
                if (pending.length === 0) {
                    try { Logger.info('[接口] 所有课程已完成，无未完成课程可刷'); } catch (_) {}
                    // 【自动暂停】仅当服务端 showProgress 明确 finished===1 才自动暂停；
                    // 否则继续运行并回退 DOM 兜底，防止把"未拉取到未完成课程"误判为"全部完成"而误停
                    if (!State._autoPausedOnComplete && await this.confirmProjectDone()) {
                        try { this.autoPauseOnComplete(); } catch (_) {}
                    }
                    return false;
                }
                // 跳过最近跳过的 + 本地已记录完成的，选下一未完成课
                const last = State.lastCourseId;
                let next = pending.find((c) => {
                    const cid = c.userCourseId || c.resourceId || '';
                    return cid !== last && !CompletedCourses.has(cid);
                });
                if (!next) {
                    // find 未命中：pending 可能全部 = 最近进入的课（接口延迟未确认完成），
                    // 或全部是本地已记录的已完成课。回退选择任一未记录的课；
                    // 绝不能把整个数组当课程对象传给 getCourseUrl / turboCompleteCourse。
                    next = pending.find((c) => !CompletedCourses.has(c.userCourseId || c.resourceId || '')) || null;
                }
                if (!next) {
                    // 无未完成课程可刷 → 仅当服务端确认全部完成才自动暂停，避免误停
                    try { Logger.info('[接口] 没有可刷的未完成课程'); } catch (_) {}
                    if (!State._autoPausedOnComplete && await this.confirmProjectDone()) {
                        try { this.autoPauseOnComplete(); } catch (_) {}
                    }
                    return false;
                }
                
                // ========== 极速模式：直接调用接口完成课程 ==========
                if (CONFIG.turboMode) {
                    const name = next.resourceName || next.resourceId || '未命名课程';
                    try { Logger.info(`[极速模式] 开始处理课程「${name}」`); } catch (_) {}
                    try { showFloatToast(`极速模式: ${name}`); } catch (_) {}
                    
                    const result = await StudyAssistant.turboCompleteCourse(next);
                    
                    if (result.success) {
                        State.lastCourseId = next.userCourseId || next.resourceId || '';
                        CompletedCourses.add(State.lastCourseId);
                        // 完成后刷新课程列表，继续下一个
                        try {
                            await new Promise(resolve => setTimeout(resolve, 2000));
                            const updatedCourses = await StudyAssistant.fetchCourses();
                            if (updatedCourses) {
                                State.allCourses = updatedCourses;
                                State.pendingCourses = StudyAssistant.getPendingCourses();
                                try { window.shuakePanelInstance?.refreshCoursePanel(); } catch (_) {}
                            }
                            
                            // 如果还有未完成课程，继续处理
                            const stillPending = StudyAssistant.getPendingCourses();
                            if (stillPending.length > 0) {
                                Logger.info(`[极速模式] 还有 ${stillPending.length} 个未完成课程，继续处理...`);
                                this._autoAdvancing = false;
                                setTimeout(() => this.autoAdvanceByAPI(), 3000);
                                return true;
                            } else {
                                Logger.success('[极速模式] 🎉 所有课程已完成！');
                                showFloatToast('所有课程已完成！');
                                // 【自动暂停】仅当服务端确认全部完成才暂停（极速模式接口可能因延迟漏报未完成课程）
                                if (await this.confirmProjectDone()) this.autoPauseOnComplete();
                                return true;
                            }
                        } catch (e) {
                            Logger.error(`[极速模式] 刷新课程列表失败: ${e.message}`);
                        }
                        return true;
                    } else if (result.needsLogin) {
                        // 【登录跳转鉴权】无登录态：已在 turboCompleteCourse 内触发跳转登录，
                        // 这里直接结束本轮，等待登录后自动续跑（不重复回退普通模式）。
                        try { Logger.warning('[极速模式] 需要登录，已引导跳转，等待登录后自动续跑...'); } catch (_) {}
                        this._autoAdvancing = false;
                        return true;
                    } else {
                        Logger.error(`[极速模式] 完成失败: ${result.message}`);
                        showFloatToast(`极速模式失败: ${result.message}`);
                        // 验证失败大概率是接口延迟（v2 已提交完成），记录为已完成，避免回退普通模式重复刷同一课
                        CompletedCourses.add(next.userCourseId || next.resourceId || '');
                        // 失败后回退到普通模式
                        Logger.warning('[极速模式] 回退到普通模式...');
                    }
                }
                
                // ========== 普通模式：进入课程（仅 weiban 域内 SPA 路由） ==========
                // 🛑 需求约束（2026-09-03）：
                //   1) 刷课不允许直接从接口返回的 url（getCourseUrl.do 的 result.data）跳转刷课页面；
                //   2) 也不允许直接跳转 iframe 的页面（课件 iframe 必须由站点 SPA 自行渲染）；
                //   3) 核心域名必须保证是 https://weiban.mycourse.cn/。
                //   因此这里完全废弃 getCourseUrl 直跳（该接口返回的 url 可能指向 wkzy/mcwk 等非 weiban
                //   子域或直接是 iframe 课件页），改为构造硬编码 weiban 域内的 hash 路由
                //   #/course/detail?… 进入课程详情页，由站点 SPA 正常加载课件（含其内部 iframe）。
                try {
                    StudyAssistant.parseURL();
                    fillStoredIdentity(StudyAssistant);
                    const cid = next.userCourseId || next.resourceId || next.courseId || '';
                    const rid = next.resourceId || next.courseId || '';
                    // 无课程 ID 时无法构造有效的 weiban 详情路由 → 回退 DOM 选择（return false）
                    if (!cid) {
                        try { Logger.warning(`[接口] 课程对象缺少 courseId/userCourseId/resourceId，回退 DOM 选择: ${next.resourceName || ''}`); } catch (_) {}
                        return false;
                    }
                    const qs = [];
                    if (StudyAssistant.userProjectId) qs.push('userProjectId=' + encodeURIComponent(String(StudyAssistant.userProjectId)));
                    if (StudyAssistant.tenantCode) qs.push('tenantCode=' + encodeURIComponent(String(StudyAssistant.tenantCode)));
                    if (StudyAssistant.userId) qs.push('userId=' + encodeURIComponent(String(StudyAssistant.userId)));
                    if (cid) qs.push('userCourseId=' + encodeURIComponent(String(cid)));
                    if (rid) qs.push('courseId=' + encodeURIComponent(String(rid)));
                    // 核心域名硬编码为 weiban，绝不使用 location.origin / 接口返回 url
                    const target = 'https://weiban.mycourse.cn/#/course/detail?' + qs.join('&');
                    const name = next.resourceName || next.resourceId || '未命名课程';
                    try { Logger.info(`[接口] 自动进入未完成课程「${name}」→ weiban 域内 SPA 路由（未使用接口返回 url）`); } catch (_) {}
                    State.lastCourseId = cid;
                    try { showFloatToast(`自动进入: ${name}`); } catch (_) {}
                    try { window.location.href = target; } catch (_) {}
                    return true;
                } catch (e) {
                    try { Logger.warning(`[接口] 构造 weiban 课程地址失败，回退 DOM 选择: ${next.resourceName || ''}`); } catch (_) {}
                }
            } catch (e) {
                try { Logger.debug(`autoAdvanceByAPI 异常: ${e.message}`); } catch (_) {}
            } finally {
                this._autoAdvancing = false;
            }
            return false;
        }

        // 处理课程列表页：选择未完成的课程
        handleCourseListPage(doc) {
            try {
                if (!doc || typeof doc.querySelectorAll !== 'function') return false;
                // 【开始刷课才运行】未点击"开始刷课"（isRunning=false）时不自动选课/刷课
                if (!State.isRunning) {
                    try { Logger.debug('未点击"开始刷课"，跳过自动选课'); } catch (_) {}
                    return false;
                }
                Logger.info('检测到课程列表页');
                const allItems = doc.querySelectorAll('.img-texts-item');
                Logger.info(`列表项数: ${allItems.length}`);
                // 先展开所有可能含未完成课程的折叠面板
                try {
                    const collapsedTitles = doc.querySelectorAll('.van-collapse-item__title:not(.van-collapse-item__title--expanded)');
                    for (const t of collapsedTitles) {
                        try {
                            const countSpan = t.querySelector('.count .active');
                            const totalSpan = t.querySelector('.count');
                            if (!totalSpan) continue;
                            const txt = totalSpan.textContent || '';
                            const m = txt.match(/(\d+)\s*\/\s*(\d+)/);
                            if (m && parseInt(m[1]) < parseInt(m[2])) {
                                Logger.info(`展开未完成面板: ${t.querySelector('.text')?.textContent?.trim() || ''}`);
                                try { DOMUtils.simulateClick(t); } catch (e) {}
                            }
                        } catch (_) {}
                    }
                } catch (_) {}
                // ① DOM 优先：通过 DOM 形式获取课程列表，模拟点击未完成的 item
                //   （站点 SPA 原生路由跳转，自动携带 courseId/userCourseId/link/projectType 等参数；
                //    已完成 item 带 passed class 会被跳过 —— 见 GraphicAdapter.selectUnfinishedCourse）
                //   展开未完成折叠面板后延迟点击，等 Vue 渲染 item 列表
                setTimeout(() => {
                    try {
                        if (GraphicAdapter.selectUnfinishedCourse(doc)) {
                            State.graphicCompleted = false;
                            State.videoCompleted = false;
                            State.hasClickedStart = false;
                            State.quizCompleted = false;
                            State.endPageJumpTime = null;
                            return; // DOM 已模拟点击未完成课程，SPA 接管跳转
                        }
                        // ② DOM 未找到未完成课程（列表未渲染/接口驱动兜底）：
                        //    接口按 listCourse.do 未完成列表进入下一课（仅 weiban 域内 SPA hash 路由，
                        //    绝不使用 getCourseUrl 返回的非 weiban URL 直跳）
                        if (CONFIG.autoAdvanceEnabled !== false) {
                            this.autoAdvanceByAPI().then((done) => {
                                if (done) return;
                                // 接口也无可刷课程 → 等待用户（仅服务端确认全部完成才自动暂停）
                                try {
                                    Logger.warning('所有课程已完成，等待用户');
                                    if (this._lastAllDoneCheck && Date.now() - this._lastAllDoneCheck < 15000) return;
                                    this._lastAllDoneCheck = Date.now();
                                    try { this.confirmProjectDone().then(ok => { if (ok) this.autoPauseOnComplete(); }); } catch (_) {}
                                } catch (e) {
                                    try { Logger.debug(`handleCourseListPage 完成确认异常: ${e.message}`); } catch (_) {}
                                }
                            }).catch(() => {});
                        } else {
                            Logger.warning('所有课程已完成，等待用户');
                            if (this._lastAllDoneCheck && Date.now() - this._lastAllDoneCheck < 15000) return;
                            this._lastAllDoneCheck = Date.now();
                            try { this.confirmProjectDone().then(ok => { if (ok) this.autoPauseOnComplete(); }); } catch (_) {}
                        }
                    } catch (e) {
                        try { Logger.debug(`handleCourseListPage setTimeout 异常: ${e.message}`); } catch (_) {}
                    }
                }, 500);
                return true;
            } catch (e) {
                try { Logger.debug(`handleCourseListPage 异常: ${e.message}`); } catch (_) {}
            }
            return false;
        }

        // 请求执行 inject (iframe 版本)
        requestInject() {
            try {
                if (window.est && typeof window.est.inject === 'function') {
                    this.doInjectInIframe();
                } else {
                    this.pendingInject = true;
                    this.doRequestInject();
                }
            } catch (e) {
                try { Logger.debug(`requestInject 异常: ${e.message}`); } catch (_) {}
            }
        }

        doRequestInject() {
            try {
                if (!this.injectKeyConfirmed) {
                    Logger.debug('等待 injectKey 确认中...');
                    try {
                        if (window.top && window.top !== window.self) {
                            window.top.postMessage({ type: "needInjectKey" }, "*");
                        }
                    } catch (e) {}
                    return;
                }

                if (!this.injectKey) {
                    Logger.warning('injectKey 不存在，跳过 inject');
                    return;
                }

                try {
                    if (window.top && window.top !== window.self) {
                        window.top.postMessage({
                            type: "doInject",
                            key: this.injectKey
                        }, "*");
                    }
                    Logger.debug(`已发送 inject 请求: ${this.injectKey}`);

                    this.injectRetries++;
                    if (this.injectRetries <= this.maxInjectRetry) {
                        this.injectRetryTimer = setTimeout(() => {
                            try {
                                if (this.pendingInject) {
                                    Logger.debug(`inject 未收到响应，重试 (${this.injectRetries}/${this.maxInjectRetry})`);
                                    this.doRequestInject();
                                }
                            } catch (e) {}
                        }, 2000);
                    } else {
                        Logger.error('inject 重试次数超限，3秒后刷新页面...');
                        this.pendingInject = false;
                        this.injectRetries = 0;
                        setTimeout(() => {
                            try { location.reload(); } catch (_) {}
                        }, 3000);
                    }
                } catch (e) {
                    Logger.error(`发送 inject 请求失败: ${e.message}`);
                }
            } catch (e) {
                try { Logger.debug(`doRequestInject 异常: ${e.message}`); } catch (_) {}
            }
        }

        // 安全发送 postMessage
        _postToTop(msg) {
            try {
                if (window.top && window.top !== window.self && typeof window.top.postMessage === 'function') {
                    window.top.postMessage(msg, "*");
                }
            } catch (e) {}
        }

        sendLog(entry) {
            try { this._postToTop({ type: "logEntry", entry }); } catch (_) {}
        }

        sendStatus(text, className = '') {
            try {
                text = String(text || '');
                className = String(className || '');
                // 【性能优化】相同状态不重复发送 postMessage（主循环每 1.2s 都会调 sendStatus）
                if (this._lastStatusText === text && this._lastStatusClass === className) return;
                this._lastStatusText = text;
                this._lastStatusClass = className;
                this._postToTop({ type: "statusUpdate", text, className });
            } catch (_) {}
        }

        sendProgress(percent) {
            try {
                const p = Number(percent) || 0;
                // 【性能优化】相同进度不重复发送 postMessage
                if (this._lastProgress === p) return;
                this._lastProgress = p;
                this._postToTop({ type: "progressUpdate", percent: p });
            } catch (_) {}
        }

        // 监听页面变化（page-active 切换）
        observePageChanges() {
            try {
                const doc = this.getDoc();
                if (!doc || !doc.body) return;

                // 释放旧的 watcher
                if (this._pageWatchStop) {
                    try { this._pageWatchStop(); } catch (_) {}
                    this._pageWatchStop = null;
                }

                let lastActiveIndex = -1;
                this._pageWatchStop = DOMWatcher.watch(
                    doc.body,
                    '.page-active',
                    (activeSection) => {
                        try {
                            let allSections = doc.querySelectorAll('.page-item');
                            if (!allSections || allSections.length === 0) {
                                try { allSections = doc.querySelectorAll('[class^="page-"]'); } catch (_) {}
                            }
                            const validSections = Array.from(allSections).filter(s =>
                                !s.classList.contains('page-start') && !s.classList.contains('page-end')
                            );
                            let currentIndex = -1;
                            for (let i = 0; i < allSections.length; i++) {
                                if (allSections[i] === activeSection) {
                                    currentIndex = i;
                                    break;
                                }
                            }
                            let currentSectionIdx = -1;
                            for (let i = 0; i < validSections.length; i++) {
                                if (validSections[i] === activeSection) {
                                    currentSectionIdx = i;
                                    break;
                                }
                            }
                            if (currentIndex !== lastActiveIndex && lastActiveIndex !== -1) {
                                try { Logger.debug(`page-active 切换: ${lastActiveIndex} -> ${currentIndex}`); } catch (_) {}
                                State.isPageTurning = false;
                            }
                            // 同步 section 索引
                            if (currentSectionIdx !== -1) {
                                State.lastActiveSectionIdx = currentSectionIdx;
                            }
                            lastActiveIndex = currentIndex;
                        } catch (_) {}
                    },
                    { once: false }
                );
            } catch (e) {
                try { Logger.debug(`observePageChanges 异常: ${e.message}`); } catch (_) {}
            }
        }

        // 主检测循环
        startWatch() {
            try {
                // 【关键修复】在创建面板前强制恢复 Vue/TDesign 全局引用
                // mcwk 页面可能在异步等待期间清空了 window.Vue/TDesign
                if (typeof window !== 'undefined') {
                    if (!window.Vue && _sandboxVueRef) {
                        window.Vue = _sandboxVueRef;
                        try { Logger.debug('startWatch: 已恢复 window.Vue'); } catch (_) {}
                    }
                    if (!window.TDesign && _sandboxTDRef) {
                        window.TDesign = _sandboxTDRef;
                        try { Logger.debug('startWatch: 已恢复 window.TDesign'); } catch (_) {}
                    }
                }
                
                // ===== 防循环：同一课程连续进入多次 → 自动跳回 weiban 首页 =====
                try {
                    if ((location.hostname || '').includes('mcwk.mycourse.cn') || /(courseId|userCourseId)=/.test(location.search)) {
                        const cid = (new URLSearchParams(location.search).get('courseId') || '')
                            || (new URLSearchParams(location.search).get('userCourseId') || '');
                        if (cid) {
                            const HKEY = 'shuake_course_repeat_v1';
                            const now = Date.now();
                            let hist = null;
                            try { hist = JSON.parse(localStorage.getItem(HKEY) || 'null'); } catch (_) {}
                            if (!hist || typeof hist !== 'object') hist = { lastId: '', sameCount: 0, ts: 0 };
                            // 时间窗口 10 分钟：超过视为新的手动进入，重置连续计数（避免误判）
                            if (now - (hist.ts || 0) > 10 * 60 * 1000) {
                                hist.sameCount = 0;
                            }
                            if (hist.lastId === cid) {
                                hist.sameCount = (hist.sameCount || 0) + 1;
                            } else {
                                hist.lastId = cid;
                                hist.sameCount = 1;
                            }
                            hist.ts = now;
                            try { localStorage.setItem(HKEY, JSON.stringify(hist)); } catch (_) {}
                            const limit = CONFIG.courseRepeatLimit || 3;
                            if (hist.sameCount >= limit) {
                                // 先重置计数，避免跳转后再进入时立刻再跳
                                hist.sameCount = 0;
                                try { localStorage.setItem(HKEY, JSON.stringify(hist)); } catch (_) {}
                                try { Logger.warning(`[防循环] 同一课程连续进入 ${limit} 次（${cid}），自动跳回 weiban 首页`); } catch (_) {}
                                try { showFloatToast('检测到重复进入同一课程，跳回首页'); } catch (_) {}
                                const homeUrl = 'https://weiban.mycourse.cn/';
                                try {
                                    if (window.top && window.top !== window) {
                                        window.top.location.href = homeUrl;
                                    } else {
                                        window.location.href = homeUrl;
                                    }
                                } catch (_) {
                                    try { window.location.href = homeUrl; } catch (_) {}
                                }
                            }
                        }
                    }
                } catch (_) {}

                if (!this.panel) {
                    this.panel = new ControlPanel();
                    // 暴露到 window 供其他模块（如答题回调）使用
                    try { window.shuakePanelInstance = this.panel; } catch (_) {}
                }

                // 从 localStorage 缓存恢复面板数据（API 未完成/失败时面板也有数据）
                try {
                    const cC = DataCache.load('category');
                    if (cC && Array.isArray(cC) && cC.length > 0) CategoryInfo.data = ensureNormalizedCategories(cC);
                    const cE = DataCache.load('exam');
                    if (cE && Array.isArray(cE) && cE.length > 0) ExamManager.data = cE;
                    const cP = DataCache.load('project');
                    if (cP && typeof cP === 'object') ProjectInfo.data = cP;
                    const cK = DataCache.load('course');
                    if (cK && typeof cK === 'object' && !CourseInfo.data) CourseInfo.data = cK;
                } catch (_) {}
                // 立即填充面板"课程 / 任务 / 考试"Tab（含缓存数据），避免一直显示无数据
                try { this.panel.refreshCoursePanel(); } catch (_) {}

                // 面板数据仍为空时的自愈：先跨域桥拿登录态/数据，再补拉 API（保证 token 就绪）
                try {
                    const hasCat = Array.isArray(CategoryInfo.data) && CategoryInfo.data.length > 0;
                    const hasExam = Array.isArray(ExamManager.data) && ExamManager.data.length > 0;
                    if (!hasCat || !hasExam) {
                        const miss = [ !hasCat ? '分类' : '', !hasExam ? '考试' : '' ].filter(Boolean).join('/');
                        Logger.info(`面板数据待补充（缺 ${miss}），后台先同步兄弟域登录态/数据再补拉`);
                        const doFetch = () => {
                            try {
                                if (!hasCat && typeof CategoryInfo.fetchDetails === 'function') {
                                    CategoryInfo.fetchDetails().then(() => { try { this.panel.refreshCoursePanel(); } catch (_) {} }).catch(() => {});
                                }
                                if (!hasExam && typeof ExamManager.fetchList === 'function') {
                                    ExamManager.fetchList().then(() => { try { this.panel.refreshCoursePanel(); } catch (_) {} }).catch(() => {});
                                }
                                if (typeof StudyAssistant !== 'undefined' && typeof StudyAssistant.fetchCourses === 'function') {
                                    StudyAssistant.fetchCourses().then(() => {
                                        State.pendingCourses = StudyAssistant.getPendingCourses();
                                        try { this.panel.refreshCoursePanel(); } catch (_) {}
                                    }).catch(() => {});
                                }
                            } catch (_) {}
                        };
                        if (typeof DataBridge !== 'undefined' && typeof DataBridge.syncFromSiblings === 'function') {
                            DataBridge.syncFromSiblings(5000).then((ok) => {
                                try {
                                    if (ok) { Logger.info(`跨域桥补全面板数据: 分类${CategoryInfo.data?.length || 0} 考试${ExamManager.data?.length || 0}`); this.panel.refreshCoursePanel(); }
                                } catch (_) {}
                                // 桥接完成后带已就绪的 token 补拉 API（若桥已带回分类/考试则不重复）
                                if (!Array.isArray(CategoryInfo.data) || CategoryInfo.data.length === 0 || !Array.isArray(ExamManager.data) || ExamManager.data.length === 0) {
                                    doFetch();
                                }
                            }).catch(() => doFetch());
                        } else {
                            doFetch();
                        }
                    }
                } catch (_) {}

                this.sendStatus('运行中');

                // 劫持 Logger 发送日志到面板（仅劫持一次）
                if (!Logger._hookedForPanel) {
                    const originalAdd = Logger.add.bind(Logger);
                    Logger.add = (level, message, data) => {
                        try {
                            originalAdd(level, message, data);
                            const entry = Logger.logs[Logger.logs.length - 1];
                            if (!entry) return;
                            if (this.isIframe) {
                                // iframe：转发给顶层面板
                                this.sendLog(entry);
                            } else if (this.panel) {
                                // 顶层：直接写入面板日志 tab
                                this.panel.addLog(entry);
                            }
                        } catch (_) {}
                    };
                    Logger._hookedForPanel = true;

                    // 一次性同步持久化/历史日志到面板（刷新后保留上次会话日志）
                    try {
                        if (!this.isIframe && this.panel && this.panel._state) {
                            const hist = (Logger.logs || []).slice().reverse(); // 旧 → 新
                            for (const e of hist) {
                                try { this.panel.addLog(e); } catch (_) {}
                            }
                        }
                    } catch (_) {}
                }

                // 监听 page-active 变化
                this.observePageChanges();

                Logger.info('开始刷课检测');
                State.startTime = Date.now();
                Statistics.init();

                // SPA 路由变化时重刷面板数据（weiban hash 路由：列表页/详情页/首页之间切换，脚本不重载）
                try {
                    if (!this.isIframe && location.host && location.host.includes('weiban')) {
                        if (this._onHashChange) window.removeEventListener('hashchange', this._onHashChange);
                        this._onHashChange = () => {
                            try {
                                // 【同步】切课重置 + 课程名解析不依赖 700ms setTimeout——后台标签页定时器被
                                // 浏览器节流（可延迟数秒甚至不执行），若放在 debounce 内则切课后 courseName 不更新、
                                // 上报记录仍是旧课程名，须刷新页面才恢复。改为 hashchange 事件触发时立即同步执行。
                                try {
                                    const _h = location.hash || '';
                                    const _qi = _h.indexOf('?');
                                    const _newCid = _qi >= 0 ? (new URLSearchParams(_h.slice(_qi + 1)).get('courseId') || '') : '';
                                    if (_newCid && _newCid !== this._lastCourseId) {
                                        this._lastCourseId = _newCid;
                                        State.resetForNewCourse();
                                        try { Logger.debug('[上报] 检测到切换课程，重置刷课计时/翻页数'); } catch (_) {}
                                    }
                                    // 【课程名】重新解析新 URL 的 courseName → currentCourseName + GM 存储（跨域）。
                                    // resetForNewCourse() 只清 studyCourseName 不清 currentCourseName，不重新解析
                                    // 则后续上报记录课程名都是第一个课程的。（hash 无 courseName 时不覆盖旧值）
                                    let _newCn = _qi >= 0 ? (new URLSearchParams(_h.slice(_qi + 1)).get('courseName') || '') : '';
                                    if (!_newCn) {
                                        try { _newCn = new URLSearchParams(location.search || '').get('courseName') || ''; } catch (_) {}
                                    }
                                    if (_newCn) {
                                        try { _newCn = decodeURIComponent(_newCn); } catch (_) {}
                                        if (_newCn && _newCn !== 'undefined') {
                                            State.currentCourseName = _newCn;
                                            try { if (typeof GM_setValue === 'function') GM_setValue('sk_course_name', _newCn); } catch (_) {}
                                            try { Logger.debug(`[路由] 课程名更新: ${_newCn}`); } catch (_) {}
                                        }
                                    }
                                } catch (_) {}
                                // 【同步】风控兜底：access-denial / status=701
                                try {
                                    if ((location.hash || '').includes('access-denial') || /status=701/.test(location.search || '')) {
                                        RiskControl.handle701(701, location.href);
                                    }
                                } catch (_) {}
                                // 数据刷新（API 拉取）仍走 debounce，避免频繁触发
                                clearTimeout(this._hashDebounce);
                                this._hashDebounce = setTimeout(() => {
                                    try {
                                        const info = PageType.getPageInfo(document);
                                        Logger.info(`[路由] hash 变化 → ${location.hash || location.pathname || '(首页)'}`);
                                        // 刷新分类/考试/项目/课程列表（API + 缓存兜底）
                                        const doRefresh = () => {
                                            try {
                                                if (typeof CategoryInfo !== 'undefined' && typeof CategoryInfo.fetchDetails === 'function') {
                                                    CategoryInfo.fetchDetails().then(() => { try { this.panel && this.panel.refreshCoursePanel(); } catch (_) {} }).catch(() => {});
                                                }
                                                if (typeof ExamManager !== 'undefined' && typeof ExamManager.fetchList === 'function') {
                                                    ExamManager.fetchList().then(() => { try { this.panel && this.panel.refreshCoursePanel(); } catch (_) {} }).catch(() => {});
                                                }
                                                if (typeof StudyAssistant !== 'undefined' && typeof StudyAssistant.fetchCourses === 'function') {
                                                    StudyAssistant.fetchCourses().then(() => {
                                                        State.pendingCourses = StudyAssistant.getPendingCourses();
                                                        try { this.panel && this.panel.refreshCoursePanel(); } catch (_) {}
                                                    }).catch(() => {});
                                                }
                                                try { this.panel && this.panel.refreshCoursePanel(); } catch (_) {}
                                                try { this.panel && this.panel.refreshProjectData(); } catch (_) {}
                                            } catch (_) {}
                                        };
                                        const isList = info.isCourseList || (typeof GraphicAdapter !== 'undefined' && typeof GraphicAdapter.isCourseListPage === 'function' && GraphicAdapter.isCourseListPage(document));
                                        if (isList) {
                                            // 回到课程列表页：刷新数据 + 重新自动选择未完成课程
                                            doRefresh();
                                            setTimeout(() => { try { this.handleCourseListPage(document); } catch (_) {} }, 1000);
                                        } else {
                                            doRefresh();
                                        }
                                    } catch (_) {}
                                }, 700);
                            } catch (_) {}
                        };
                        window.addEventListener('hashchange', this._onHashChange);
                        Logger.debug('[路由] 已注册 hashchange 数据刷新监听');
                    }
                } catch (e) {
                    try { Logger.debug(`hashchange 监听注册异常: ${e.message}`); } catch (_) {}
                }

                if (this.loopTimer) clearInterval(this.loopTimer);

                // 更新统计信息的定时器
                if (this.statsTimer) clearInterval(this.statsTimer);
                this.statsTimer = safeInterval(() => {
                    try {
                        if (this.panel) {
                            this.panel.updateStats(Statistics.getSummary());
                        }
                    } catch (e) {}
                }, 5000);

                this.loopTimer = safeInterval(() => {
                    try {
                        // 【课程名·宿主同步兜底】宿主页（weiban 域）每 3s 把当前 URL courseName 同步到 GM 存储，
                        // 兜底 hashchange 未触发 / iframe 早于宿主更新等时序问题（后台运行、直接打开详情页），
                        // 保证 mcwk iframe 上报读取的课程名与宿主页当前课程一致。
                        if (!this.isIframe && typeof location !== 'undefined' && location.host && location.host.indexOf('weiban') !== -1) {
                            try {
                                const _nowL = Date.now();
                                if (!this._courseSyncAt || (_nowL - this._courseSyncAt) >= 3000) {
                                    this._courseSyncAt = _nowL;
                                    const _hL = location.hash || '';
                                    const _qiL = _hL.indexOf('?');
                                    let _cnL = _qiL >= 0 ? (new URLSearchParams(_hL.slice(_qiL + 1)).get('courseName') || '') : '';
                                    if (!_cnL) {
                                        try { _cnL = new URLSearchParams(location.search || '').get('courseName') || ''; } catch (_) {}
                                    }
                                    if (_cnL) {
                                        try { _cnL = decodeURIComponent(_cnL); } catch (_) {}
                                        if (_cnL && _cnL !== 'undefined') {
                                            const _curG = (typeof GM_getValue === 'function') ? GM_getValue('sk_course_name', '') : '';
                                            if (_cnL !== _curG) {
                                                try { if (typeof GM_setValue === 'function') GM_setValue('sk_course_name', _cnL); } catch (_) {}
                                                State.currentCourseName = _cnL;
                                                try { Logger.debug(`[课程名] 主循环同步: ${_cnL}`); } catch (_) {}
                                            }
                                        }
                                    }
                                }
                            } catch (_) {}
                        }
                        if (State.isPaused || !State.isRunning) return;
                        this.checkPage();
                    } catch (e) {
                        try { Logger.debug(`主循环异常: ${e.message}`); } catch (_) {}
                    }
                }, Math.max(500, CONFIG.checkInterval || 1200));
            } catch (e) {
                try { Logger.error(`startWatch 异常: ${e.message}`); } catch (_) {}
            }
        }

        // 注册视频事件监听（用于 mcwk 直接模式）
        registerVideoEvents() {
            try {
                // 【修复】不再限制 isMcwkDirect：weiban.mycourse.cn 的 iframe videojs 播放器
                // 同样需要注册 ended 事件，否则视频真实播完后无法及时触发完成。
                const player = VideoAdapter.getPlayer('videojs', document, window);
                if (player && typeof player.on === 'function') {
                    if (!player.__skEndedBound) {
                        player.__skEndedBound = true;
                        try {
                            player.on('ended', () => {
                                Logger.success('VideoJS 播放结束事件触发');
                                try { this.handleVideoComplete(); } catch (e) {}
                            });
                        } catch (e) {}
                        try {
                            player.on('error', () => {
                                Logger.warning('VideoJS 播放错误');
                            });
                        } catch (e) {}
                        Logger.debug('VideoJS ended 事件已注册');
                    }
                }
            } catch (e) {
                try { Logger.debug(`registerVideoEvents 异常: ${e.message}`); } catch (_) {}
            }
        }

        // 获取 iframe 内的文档
        getIframeDoc() {
            try {
                const iframe = document.querySelector('.page-iframe, iframe[src*="mycourse"]');
                if (iframe && iframe.contentDocument) {
                    return iframe.contentDocument;
                }
            } catch (e) {}
            return null;
        }

        // 获取主文档或 iframe 内的文档
        // 【性能优化】结果缓存：主循环每 1.2s 调一次 getDoc，而页面结构在轮询间基本不变。
        // 缓存命中时跳过 iframe 遍历（每轮 4 次查询 + iframe 逐个探测），显著降低每轮开销。
        // 缓存有效期 600ms：主循环 1.2s 一轮，保证每轮至少重算一次，能及时感知页面/iframe 切换。
        getDoc() {
            const now = Date.now();
            if (this._getDocCache && this._getDocCache.doc
                && (now - this._getDocCache.ts) < 600
                && this._getDocCache.doc === document
                && this._getDocCache.pageSignature === (this._getDocPageSig ? this._getDocPageSig() : null)) {
                return this._getDocCache.doc;
            }
            // 1. 顶层文档若本身就是视频/播放器页面（直开 mcwk、page-WH.page-video），
            //    直接返回顶层，避免误拿到外层课程页 iframe 的图文 DOM
            try {
                if (document.querySelector('video, .video-js, #my-video, .page-WH.page-video, section.page-WH.page-video')) {
                    this._setGetDocCache(document);
                    return document;
                }
            } catch (_) {}

            // 2. 优先使用当前文档（避免跨域问题）
            try {
                const localPageItems = document.querySelector('.page-item, .page-slide');
                if (localPageItems) {
                    this._setGetDocCache(document);
                    return document;
                }
            } catch (_) {}

            try {
                // 遍历所有 iframe 查找图文内容文档（覆盖非挂载命名/隐藏/嵌套 iframe，
                // 不依赖特定 class/src，只要 contentDocument 含 .page-item/.page-slide 即命中）
                // 递归扫描 iframe（含嵌套多层），寻找承载图文内容的文档。
                const findContentDoc = (rootDoc, depth) => {
                    if (depth > 5) return null;
                    let iframes = [];
                    try { iframes = Array.from(rootDoc.querySelectorAll('iframe')); } catch (_) { return null; }
                    for (const iframe of iframes) {
                        let iframeDoc = null;
                        try { iframeDoc = iframe.contentDocument || (iframe.contentWindow && iframe.contentWindow.document); } catch (_) {}
                        if (!iframeDoc) continue;
                        try {
                            const hasPageItems = iframeDoc.querySelector('.page-item, .page-slide');
                            if (hasPageItems) { this._setGetDocCache(iframeDoc); return iframeDoc; }
                        } catch (_) {}
                        // 新版编号页模板（btn-aq-n/btn-aq-y）：页面无 .page-item，改用
                        // .page-start/.page-reciprocal/.page-end 或 ≥2 个 [class^="page-"] 识别内容文档
                        try {
                            const hasNewPages = iframeDoc.querySelector('.page-start, .page-reciprocal, .page-end') ||
                                (iframeDoc.querySelectorAll('[class^="page-"]').length >= 2);
                            if (hasNewPages) { this._setGetDocCache(iframeDoc); return iframeDoc; }
                        } catch (_) {}
                        // 嵌套 iframe 递归
                        const nested = findContentDoc(iframeDoc, depth + 1);
                        if (nested) return nested;
                    }
                    return null;
                };
                const found = findContentDoc(document, 0);
                if (found) return found;
            } catch (_) {}

            this._setGetDocCache(document);
            return document;
        }

        // getDoc 缓存写入与页面签名（快速判断主文档结构是否变化，变化时强制刷新缓存）
        _setGetDocCache(doc) {
            try {
                this._getDocCache = { doc, ts: Date.now() };
            } catch (_) {}
        }

        _getDocPageSig() {
            try {
                // 主文档中是否出现视频/图文关键结构（快速签名，避免缓存穿透到已切换的页面）
                return (document.querySelector('video') ? 'v' : '') + (document.querySelector('.page-item, .page-slide') ? 'p' : '');
            } catch (_) {
                return '';
            }
        }

        checkPage() {
            let doc = null;
            try {
                doc = this.getDoc();
                if (!doc) {
                    Logger.debug('获取文档失败：doc 为空');
                    Statistics.recordError();
                    return;
                }
            } catch (e) {
                try { Logger.debug(`获取文档失败: ${e.message}`); } catch (_) {}
                Statistics.recordError();
                return;
            }

            try {
                this.checkPageInternal(doc);
            } catch (e) {
                try { Logger.error(`页面检测异常: ${e.message}`, e?.stack); } catch (_) {}
                Statistics.recordError();
            }
        }

        checkPageInternal(doc) {
            if (!doc) return;
            // 【作用域修复】_activeSection/_validSections 必须在方法体最外层声明，
            // 因为 checkPageInternal 中 11946 行（点击开始按钮分支）在 11726 try 块之外引用它。
            // 若在嵌套 try 块内用 let 声明，块级作用域会导致外层引用时 ReferenceError:
            // "_activeSection is not defined"。此处提升声明，下方 11744 处仅赋值。
            let _activeSection = null;
            let _validSections = [];
            try {
                // ===== Canvas 微课（CreateJS 动画课）优先处理 =====
                // wkzy.mycourse.cn/9080/... 等 shareList 课程页：结构是 canvas + exportRoot 动画，
                // 无 .page-item/.btn-next，现有图文/视频逻辑不适用，由 CanvasCourse 适配器接管。
                try {
                    if (CanvasCourse.handle(doc)) {
                        return;
                    }
                } catch (_) {}

                // 【跨域课程 iframe 守卫】图文/视频内容若在跨域 mcwk iframe 内（顶层无法读取
                // contentDocument），则刷课由 iframe 内脚本实例负责；顶层仅识别一次并静默返回，
                // 避免每轮反复误报 "[图文结构诊断:start-fail]"。
                try {
                    if (!this.isIframe && !(location.hostname || '').includes('mcwk.mycourse.cn')
                        && CanvasCourse.hasCrossOriginCourseFrame(doc)) {
                        if (!this._crossOriginLogged) {
                            this._crossOriginLogged = true;
                            try { Logger.info('检测到跨域课程 iframe（mcwk），图文/视频刷课由 iframe 内实例执行'); } catch (_) {}
                        }
                        return;
                    }
                } catch (_) {}

                // 【上报计时提前】检测到课程内容（图文 page-item/翻页按钮/视频/Canvas 微课）即开始计时，
                // 避免"首次翻页/完成瞬间才初始化 studyStartedAt"导致上报 duration=0s。
                // ensureStarted 惰性（已开始则跳过），登录云端后生效，未登录无副作用。
                try {
                    const hasCourseContent =
                        doc.querySelector('.page-item, .btn-next, .btn-aq, .btn-at, .btn-af, video, .vjs-tech, .video-js')
                        || (typeof CanvasCourse !== 'undefined' && CanvasCourse.isCanvasPage(doc));
                    if (hasCourseContent) {
                        StudyReporter.ensureStarted();
                    }
                } catch (_) {}

                // 计算当前活跃 section 索引（排除 page-start/page-end）
                // 【性能优化】一次缓存页面项 NodeList，供本函数内"点击前"的多次纯读取复用，
                // 避免每轮主循环重复 8~10 次全量 querySelectorAll。
                // 优先 .page-item（经典模板）；无 .page-item 时退回编号页（新版 btn-aq-n 模板，无 .page-item class）
                let _pageItems = (doc && typeof doc.querySelectorAll === 'function') ? doc.querySelectorAll('.page-item') : null;
                if (!_pageItems || _pageItems.length === 0) {
                    try {
                        _pageItems = doc.querySelectorAll(
                            '[class^="page-"]' +
                            ':not([class*="page-video"]):not([class*="page-wh"])' +
                            ':not([class*="page-header"]):not([class*="page-footer"])' +
                            ':not([class*="page-wrapper"]):not([class*="page-container"])' +
                            ':not([class*="page-iframe"]):not([class*="page-slide"])' +
                            ':not([class*="page-graphic"]):not([class*="page-area"])' +
                            ':not([class*="page-content"]):not([class*="page-box"])'
                        );
                    } catch (_) {}
                }
                // 【性能优化】基于已缓存的 _pageItems 一次性推导活跃 section 与有效 section 列表，
                // 替换本函数内 9 处重复的 querySelector('.page-item.page-active') 与
                // 3 处重复的 querySelectorAll('.page-item')+filter。
                // 同一轮主循环内 DOM 无异步变化，这些纯读取查询结果必然一致，替换语义完全等价。
                // 注意：这里只是赋值（不再 let 声明），变量已在方法体最外层声明，避免块级 shadowing
                _activeSection = null;
                _validSections = [];
                try {
                    const _sectionsArr = _pageItems ? Array.from(_pageItems) : [];
                    for (const s of _sectionsArr) {
                        if (s.classList && s.classList.contains('page-active')) {
                            _activeSection = s;
                            break;
                        }
                    }
                    _validSections = _sectionsArr.filter(s =>
                        !s.classList.contains('page-start') && !s.classList.contains('page-end')
                    );
                } catch (_) {}
                // 【防回退·page-start 复激活守卫】站点 2500ms setTimeout 会在脚本已开始后
                // 无条件给 .page-start 重复加 page-active（clearLoader 只保证自己不重复激活，
                // 挡不住站点自己的定时器），造成"page-start + 正读页"双活跃页 → 被误判回起始页
                // → 反复点击 .btn-start → 站点 BtnFn 把 page-active 加回 page-0 → 进度被拉回第 1 页
                // → 死循环（日志特征：每轮 section 切换 0->1 / startCourse 再次调用 / 当前页始终 1/N）。
                // 规则：只要存在任一非 page-start 的活跃页，就移除 .page-start 的 page-active 并重选 _activeSection。
                // 必须放在 section 切换检测之前，否则检测会基于被污染的双活跃态误重置 hasClickedStart。
                try {
                    const _secArr = Array.from(_pageItems || []);
                    const _actArr = _secArr.filter(x => x.classList && x.classList.contains('page-active'));
                    const _nonStartA = _actArr.find(x => !x.classList.contains('page-start'));
                    const _startA = _actArr.find(x => x.classList.contains('page-start'));
                    if (_nonStartA && _startA) {
                        try { _startA.classList.remove('page-active'); } catch (_) {}
                        try { Logger.debug('[page-start 复激活守卫] 移除站点 2500ms 定时器误加的 page-active'); } catch (_) {}
                        _activeSection = _nonStartA;
                    }
                } catch (_) {}
                let currentSectionIdx = -1;
                let currentPageIdx = -1;
                try {
                    const sections = Array.from(_pageItems || []);
                    const validSections = sections.filter(s =>
                        !s.classList.contains('page-start') && !s.classList.contains('page-end')
                    );
                    for (let i = 0; i < validSections.length; i++) {
                        if (validSections[i].classList.contains('page-active')) {
                            currentSectionIdx = i;
                            break;
                        }
                    }
                    // 也记录原始 page-item 索引（用于观察 section 切换）
                    for (let i = 0; i < sections.length; i++) {
                        if (sections[i].classList.contains('page-active')) {
                            currentPageIdx = i;
                            break;
                        }
                    }
                } catch (_) {}

                // ===== section 切换检测 =====
                // 方案：页面 URL 不变，但 .page-active 会在不同 section 间切换
                // 通过记录"过滤后 section 索引"判断是否发生了切换
                if (State.lastActiveSectionIdx !== null && currentSectionIdx !== -1) {
                    if (State.lastActiveSectionIdx !== currentSectionIdx) {
                        // section 真正切换了（如点击开始按钮后 page-start → 第1页）
                        try { Logger.debug(`section 切换: ${State.lastActiveSectionIdx} -> ${currentSectionIdx}`); } catch (_) {}

                        // 【BUG FIX】只在"刚从 page-start 进入图文正文"时才重置 hasClickedStart
                        // 普通翻页（page-0 → page-1 → ... → page-N）不应触发 btn-start 搜索，
                        // 否则会出现"已点击 btn-next 翻页，但又去找 btn-start → 误点隐藏的 page-start
                        // → 被站点拉回 page-0"的死循环。
                        const prevRawIdx = State.lastActiveRawPageIdx;
                        let prevWasStartPage = false;
                        if (prevRawIdx !== null && prevRawIdx >= 0 && _pageItems) {
                            try {
                                const prevRaw = _pageItems.item(prevRawIdx);
                                if (prevRaw && prevRaw.classList.contains('page-start')) {
                                    prevWasStartPage = true;
                                }
                            } catch (_) {}
                        }

                        if (prevWasStartPage) {
                            // 真的从 page-start 翻出，需要清掉开始按钮相关状态
                            State.hasClickedStart = false;
                            State.startBtnClickTime = null;
                            State.startBtnRetryCount = 0;
                            State.startBtnClickedSectionIdx = null;
                            State._startBtnWatched = false;
                            State.videoPlayStartTime = null;
                            State.injectExecuted = false;
                            State.endPageJumpTime = null;
                            State.graphicCompleted = false;
                            State.quizCompleted = false;
                            State.videoCompleted = false;
                            State.stuckCount = 0;
                        }
                        GraphicAdapter.clearPageTurnLock();
                        State.lastActiveSectionId = null;
                        State.lastActiveSectionIdx = currentSectionIdx;
                    }
                }

                // 【BUG FIX】检测"刚进入新的 page-start"（例如切换到下一组图文）。
                // 由于 page-start 不在 validSections 中，上面的 validSections 切换检测不会触发，
                // 但 hasClickedStart 仍可能停留在上一组的 true 状态，导致下一组图文卡住。
                if (currentPageIdx !== -1 && State.lastActiveRawPageIdx !== null
                    && currentPageIdx !== State.lastActiveRawPageIdx) {
                    try {
                        const currRaw = _pageItems ? _pageItems.item(currentPageIdx) : null;
                        const prevRawEl = _pageItems ? _pageItems.item(State.lastActiveRawPageIdx) : null;
                        const currIsStartPage = currRaw && currRaw.classList.contains('page-start');
                        const prevIsNotStart = !(prevRawEl && prevRawEl.classList.contains('page-start'));
                        if (currIsStartPage && prevIsNotStart) {
                            // 刚切到下一组的起始页，重置开始按钮状态以便再次点击
                            State.hasClickedStart = false;
                            State.startBtnClickTime = null;
                            State.startBtnRetryCount = 0;
                            State.startBtnClickedSectionIdx = null;
                            State._startBtnWatched = false;
                            State.videoPlayStartTime = null;
                            State.graphicCompleted = false;
                            State.quizCompleted = false;
                            State.videoCompleted = false;
                            State.forceAdvanceReverts = 0;
                            State.lastForceAdvanceIdx = null;
                            State.lastForceAdvanceTime = null;
                            State.boxWaitCount = 0;
                            State.lastReclickKey = null;
                            State.reclickCount = 0;
                            try { Logger.debug(`section 切换: 进入新一组图文起始页 (raw ${State.lastActiveRawPageIdx} -> ${currentPageIdx})`); } catch (_) {}
                        }
                    } catch (_) {}
                }
                // 同步更新原始 page-item 索引（用于下次判断"上一个 section 是不是 page-start"）
                if (currentPageIdx !== -1) {
                    State.lastActiveRawPageIdx = currentPageIdx;
                }

                // 首次进入或初始化
                if (State.lastActiveSectionIdx === null && currentSectionIdx !== -1) {
                    State.lastActiveSectionIdx = currentSectionIdx;
                }
                // 哨兵三态：false=未注册、true=等待中(已注册 DOMWatcher)、'clicked'=已点击。
                // 只在初始未定义时兜底为 false；绝不能把 true(等待中) 或 'clicked' 重置为 false，
                // 否则每轮主循环都会重新注册 DOMWatcher（新建 MutationObserver + 反复"开始按钮未找到"日志）。
                if (State._startBtnWatched == null) {
                    State._startBtnWatched = false;
                }

                // ===== 翻页超时 / 已成功检测 =====
                if (State.isPageTurning && State.pageTurnTriggerTime) {
                    const elapsed = Date.now() - State.pageTurnTriggerTime;
                    if (elapsed > (CONFIG.pageTurnDelay || 1500) * 5 + 5000) {
                        try { Logger.warning(`翻页超时（${elapsed}ms），强制解锁`); } catch (_) {}
                        GraphicAdapter.clearPageTurnLock();
                    } else if (GraphicAdapter.hasPageTurned(doc)) {
                        try { Logger.debug(`翻页已成功（${elapsed}ms），提前解锁`); } catch (_) {}
                        State.stuckCount = 0;
                        GraphicAdapter.clearPageTurnLock();
                    }
                }

                // 【强制翻页回退检测】强制翻页（切 class）后，若站点把 page-active 打回到更早的页，
                // 说明该页无法通过 class 切换推进（站点校验真实进度），累计 2 次即停用强制翻页。
                if (State.lastForceAdvanceIdx !== null && State.lastForceAdvanceIdx >= 0) {
                    try {
                        const validNow = Array.from(_pageItems || []).filter(s =>
                            !s.classList.contains('page-start') && !s.classList.contains('page-end'));
                        const nowIdx = validNow.findIndex(s => s.classList.contains('page-active'));
                        const backElapsed = State.lastForceAdvanceTime ? (Date.now() - State.lastForceAdvanceTime) : 999999;
                        if (nowIdx !== -1 && nowIdx < State.lastForceAdvanceIdx && backElapsed < 15000) {
                            State.forceAdvanceReverts = (State.forceAdvanceReverts || 0) + 1;
                            try { Logger.warning(`强制翻页被站点回退（目标 ${State.lastForceAdvanceIdx} -> 当前 ${nowIdx}），累计 ${State.forceAdvanceReverts} 次`); } catch (_) {}
                        }
                    } catch (_) {}
                    State.lastForceAdvanceIdx = null;
                    State.lastForceAdvanceTime = null;
                }
            } catch (e) {
                try { Logger.debug(`页面变化检测异常: ${e.message}`); } catch (_) {}
            }

            // 翻页中，阻断不必要的重复触发（开始按钮、验证码等仍允许）
            // （无 else 空块，仅做日志提示）
            if (State.isPageTurning) {
                // Logger.debug('翻页中，阻断重复触发');
            }

            const pageInfo = PageType.getPageInfo(doc);

            // 【课程标题兜底】若当前课程名未知，按优先级回填真实课程标题：
            //   ① URL courseName 参数（weiban 域 #/course/detail?courseName=...，图文/视频通用，最可靠）
            //   ② 课件 iframe 内第一个 h2（mcwk 课件页挂载 iframe 标题）
            try {
                if (!State.currentCourseName || State.currentCourseName === '未知课程' || State.currentCourseName === '未知') {
                    // ① URL 通用解析：从 hash/search 的 courseName 参数解码
                    let nameFromUrl = '';
                    try {
                        const hash = (typeof location !== 'undefined' && location.hash) || '';
                        const qsIdx = hash.indexOf('?');
                        if (qsIdx >= 0) {
                            const p = new URLSearchParams(hash.slice(qsIdx + 1)).get('courseName');
                            if (p) nameFromUrl = decodeURIComponent(p);
                        }
                        if (!nameFromUrl) {
                            const sp = new URLSearchParams((typeof location !== 'undefined' && location.search) || '').get('courseName');
                            if (sp) nameFromUrl = decodeURIComponent(sp);
                        }
                    } catch (_) {}
                    if (nameFromUrl) {
                        State.currentCourseName = nameFromUrl;
                        try { Logger.debug(`[标题] 从 URL courseName 解析课程标题: ${State.currentCourseName}`); } catch (_) {}
                    } else if (pageInfo && pageInfo.courseTitle) {
                        State.currentCourseName = pageInfo.courseTitle;
                        try { Logger.debug(`[标题] 从课件 iframe 解析课程标题: ${State.currentCourseName}`); } catch (_) {}
                    }
                }
            } catch (_) {}

            // ===== 视频/图文互斥修正（最高优先级短路） =====
            // 真实视频页（iframe 内含 .vjs-tech/.video-js/video 或 顶层直接有 video）
            // 绝不能进入"图文开始/翻页/答题/结束"链路，否则会出现"当前是视频啊点 jb 开始按钮"等误操作。
            // 先在 doc 顶层 + 最可能承载内容的 page-iframe 子文档 双重校验，避免 PageType.getPageInfo
            // 因 allDocs 顺序/跨域 漏判而造成误进图文链路。
            let skipGraphicFlow = false;
            try {
                const hasVideoSignal = (d) => {
                    if (!d || typeof d.querySelector !== 'function') return false;
                    try {
                        // 图文课程守卫：有图文结构标记即使含真实内嵌视频也算图文
                        if (d.querySelector('.page-item, .page-start, .page-reciprocal, .page-end, .btn-next, .btn-aq, .btn-at, .btn-af, .btn-aq-n, .btn-aq-y')) return false;
                    } catch (_) {}
                    try {
                        // 明确视频标记（旧版 videojs / DPlayer / page-video 等）：无条件视为视频
                        if (d.querySelector('.video-js, .vjs-tech, #my-video, .my-video-dimensions, .dplayer, [class*="page-video"]')) return true;
                    } catch (_) {}
                    try {
                        // 原生 <video> / xgplayer：仅当携带真实视频源（src/source/duration）才算视频；
                        // 新版图文模板用 xgplayer 建"空 URL 播放器桩"（Hlsplay('mse','')），src 为空，不算视频。
                        if (d.querySelector('video') || d.querySelector('.xgplayer, [class*="xgplayer"]')) {
                            if (GraphicAdapter.hasRealVideoSource(d)) return true;
                        }
                    } catch (_) {}
                    try {
                        const ss = d.querySelectorAll('script[src]');
                        for (let i = 0; i < ss.length; i++) {
                            const sr = ss[i].getAttribute('src') || '';
                            if (/video-js-cdn|videojs-contrib-hls/.test(sr)) return true;
                            // video-play-loader（新版模板图文/视频共用）：仅当确有真实视频源才算
                            if (/video-play-loader|video-play-unlodaer/.test(sr) && GraphicAdapter.hasRealVideoSource(d)) return true;
                        }
                    } catch (_) {}
                    return false;
                };
                if (pageInfo.isVideo) skipGraphicFlow = true;
                if (!skipGraphicFlow && hasVideoSignal(doc)) skipGraphicFlow = true;
                if (!skipGraphicFlow) {
                    try {
                        const iframes = document.querySelectorAll('iframe.page-iframe, iframe[class*="iframe"], iframe[src*="mycourse"], iframe[src*="course"]');
                        for (let i = 0; i < iframes.length; i++) {
                            const iframe = iframes[i];
                            let id = null;
                            try { id = iframe.contentDocument || (iframe.contentWindow && iframe.contentWindow.document); } catch (_) {}
                            if (id && hasVideoSignal(id)) { skipGraphicFlow = true; break; }
                        }
                    } catch (_) {}
                }
                // 互斥同步：若本层判定为视频 → 强制修正 PageType 结果 isVideo=true / isGraphic=false，
                // 避免后续代码读 pageInfo 仍走图文分支。
                if (skipGraphicFlow) {
                    pageInfo.isVideo = true;
                    pageInfo.isGraphic = false;
                    // 视频页：彻底清理"图文开始/翻页"残留状态，避免 hasClickedStart=true 带着上一组图文的状态
                    // 进入新视频页导致反复触发开始按钮兜底。
                    try {
                        State.hasClickedStart = false;
                        State.startBtnClickTime = null;
                        State.startBtnRetryCount = 0;
                        State.startBtnClickedSectionIdx = null;
                        State._startBtnWatched = false;
                        State.graphicCompleted = false;
                        State.quizCompleted = false;
                        State.boxWaitCount = 0;
                    } catch (_) {}
                }
            } catch (_) {}

            // 课程列表页
            try {
                if (pageInfo.isCourseList || GraphicAdapter.isCourseListPage(doc)) {
                    if (this.handleCourseListPage(doc)) {
                        return;
                    }
                }
            } catch (e) {
                try { Logger.debug(`课程列表页处理异常: ${e.message}`); } catch (_) {}
            }

            // 验证码页面
            if (pageInfo.isCaptcha) {
                if (!State.isCaptchaPage) {
                    State.isCaptchaPage = true;
                    this.sendStatus('请完成验证', 'warning');
                    Logger.warning('检测到验证码页面，请手动完成验证');
                }
                return;
            }
            State.isCaptchaPage = false;

            // 课程选择页
            try {
                if (GraphicAdapter.isCourseSelectPage(doc)) {
                    if (GraphicAdapter.handleCourseSelectPage(doc)) {
                        return;
                    }
                }
            } catch (e) {
                try { Logger.debug(`课程选择页处理异常: ${e.message}`); } catch (_) {}
            }

            // 考试页面 AI 答题（提前到图文流程之前）：结课考试页 .exam-container 无 .page-item/.btn-start，
            // 若放在图文 Loader/开始之后，会被 startCourse 误判"未开始"反复重试，永远到不了考试检测
            // （用户实测：考试页反复打印"暂无法 JS 触发开始"）。
            try {
                if (AIAnswer.isExamPage(doc) && CONFIG.enableAIAnswer) {
                    this.sendStatus('AI 答题中...');
                    AIAnswer.processExamPage(doc);
                    return;
                }
            } catch (e) {
                try { Logger.debug(`AI 答题异常: ${e.message}`); } catch (_) {}
            }

            // ===== 视频页互斥：跳过全部图文 Loader / 开始 / 翻页 / 答题 / 结束 链路 =====
            // 用户日志：视频页仍不停打印"✅ 已点击开始按钮"，根因是图文开始流程未对视频页做短路。
            if (skipGraphicFlow) {
                // 交给 checkPageInternal 后续的"视频完成处理"（倍速 / 播放检测 / 完成后翻页）
                // 不再做任何图文类操作。
            } else {

            // ===== 图文 Loader 初始化 & 开始学习（JS 优先） =====
            // A) 跳过页面 2500ms loader 初始化：用户 item.js 中：
            //   setTimeout( hide loader + show page-container + activate page-start , 2500 )
            // 这里只在"页面确实仍在等待 loader 或尚未激活任何一页"时手动推进，
            // 避免翻到中间页（page-3、page-reciprocal 等）时，若某轮 DOM 读取间隙
            // 出现短暂 no-active，clearLoader 会错误把 page-start.page-active 填回去 →
            // 然后下一轮又触发 startCourse（开始按钮重复点击）。
            try {
                if (GraphicJsAdapter.hasNativeSupport()) {
                    let needClear = false;
                    try {
                        const loader = doc.querySelector('.loader');
                        const loaderVisible = !!(loader && loader.style && loader.style.display !== 'none');
                        const anyActive = !!doc.querySelector('.page-item.page-active');
                        needClear = loaderVisible || !anyActive;
                    } catch (_) { needClear = true; }
                    if (needClear) {
                        const ld = GraphicJsAdapter.clearLoader(doc);
                        if (ld.ok && ld.reason !== 'already-done') {
                            try { Logger.info(`[JS优先·Loader] 跳过 2500ms 初始化 → ${ld.reason}`); } catch (_) {}
                        }
                    }
                }
            } catch (_) {}

            // 点击开始按钮
            const activeSection = _activeSection || doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
            if (!State.hasClickedStart) {
                // B) 【JS 优先】调用页面原生 BtnFn(".btn-start", ".page-start", ".page-0") 或直接 class 切换，
                //    绕过节流 & 不需要 start 按钮可见 & 确保音效 handler 被完整触发。
                //    只有 JS 优先未生效时才回退原有 findStartButton + 模拟点击链。
                let jsStarted = false;
                try {
                    // 仅在当前确实在 page-start 时触发（若已经在 page-0 或之后则不需要）
                    const curActive = activeSection;
                    const onStartPage = curActive && (
                        curActive.classList.contains('page-start') ||
                        /(^|\s)page-start(\s|$)/.test(curActive.className || '')
                    );
                    if (GraphicJsAdapter.hasNativeSupport() && onStartPage) {
                        const startRes = GraphicJsAdapter.startCourse(doc);
                        if (startRes.ok) {
                            try { Logger.info(`[JS优先·开始] startCourse → ${startRes.reason}`); } catch (_) {}
                            State.hasClickedStart = true;
                            State.startBtnClickTime = Date.now();
                            State.startBtnRetryCount = 0;
                            State._startBtnWatched = 'clicked';
                            try {
                                const validSections = Array.from(_pageItems || []).filter(s =>
                                    !s.classList.contains('page-start') && !s.classList.contains('page-end')
                                );
                                const clickedIdx = validSections.findIndex(s => s.classList.contains('page-active'));
                                State.startBtnClickedSectionIdx = (clickedIdx !== -1) ? clickedIdx : 0;
                            } catch (_) { State.startBtnClickedSectionIdx = 0; }
                            jsStarted = true;
                        }
                    }
                } catch (_) { jsStarted = false; }

                if (!jsStarted) {
                    // 【移除开始按钮 DOM 判断兜底】
                    // 用户强需求：图文开始流程不依赖 findStartButton / startBtn 可见性判断，
                    // 仅使用 JS 级等价操作（GraphicJsAdapter.startCourse 内部已含 jQuery trigger /
                    // BtnFn 调用 / class 切换三级兜底），不再回退 DOM 模拟点击链。
                    let fallbackStarted = false;
                    // 【防回退·关键】兜底也必须在"起始页（或无活跃页）"时才调用 startCourse：
                    // startCourse 内部会根据活跃页是 .page-0 自动选 direction=prev（prevstart-manual-class，
                    // 把 page-active 拉回 page-start）。若课程已在正文（如 page-0 视频页）调用它，
                    // 会被拉回起始页 → "进入新一组图文起始页" 重置 hasClickedStart → 再点 start
                    // → 回到 page-0 → 死循环（日志特征：prevstart-manual-class / raw 1->0 每轮循环）。
                    try {
                        const curActiveF = activeSection;
                        const onStartPageF = !!(curActiveF && (
                            curActiveF.classList.contains('page-start') ||
                            /(^|\s)page-start(\s|$)/.test(curActiveF.className || '')
                        ));
                        if (!onStartPageF && curActiveF) {
                            // 课程已在正文（非起始页且有活跃页）→ 禁止反向拉回，交给翻页/视频逻辑
                            fallbackStarted = false;
                        } else {
                            // 即使 hasNativeSupport=false（纯页面结构但无全局函数暴露）也尝试 class 切换。
                            const fallbackRes = GraphicJsAdapter.startCourse(doc);
                        if (fallbackRes && fallbackRes.ok) {
                            try { Logger.info(`[JS优先·开始·兜底] startCourse 再次调用 → ${fallbackRes.reason}`); } catch (_) {}
                            fallbackStarted = true;
                        } else {
                            // 最后兜底：手动移除 page-start.page-active / 下一个 page-item 加 active
                            // （与 GraphicJsAdapter class-switch 分支等价，但不依赖类内部实现）
                            const ps = doc.querySelector('.page-start.page-item.page-active') || doc.querySelector('.page-start.page-active');
                            if (ps && ps.classList && ps.classList.contains('page-active')) {
                                let target = null;
                                const sibs = (ps._parent && ps._parent._children) ? ps._parent._children
                                    : Array.from(doc.querySelectorAll('.page-container > .page-item, .page-container > section, .page-container > [class^="page-"]'));
                                const idx = sibs.indexOf ? sibs.indexOf(ps) : -1;
                                if (idx >= 0 && idx < sibs.length - 1) target = sibs[idx + 1];
                                if (!target) target = doc.querySelector('.page-0.page-item, [class*="page-0"].page-item');
                                if (target) {
                                    try { ps.classList.remove('page-active'); } catch (_) {}
                                    try { target.classList.add('page-active'); } catch (_) {}
                                    try { Logger.info('[JS优先·开始·兜底·硬切] page-start → 下一 page-item'); } catch (_) {}
                                    fallbackStarted = true;
                                }
                            }
                        }
                        }
                    } catch (_) { fallbackStarted = false; }

                    if (fallbackStarted) {
                        State.hasClickedStart = true;
                        State.startBtnClickTime = Date.now();
                        State.startBtnRetryCount = 0;
                        State._startBtnWatched = 'clicked';
                        try {
                            const validSections = Array.from(_pageItems || []).filter(s =>
                                !s.classList.contains('page-start') && !s.classList.contains('page-end')
                            );
                            const clickedIdx = validSections.findIndex(s => s.classList.contains('page-active'));
                            State.startBtnClickedSectionIdx = (clickedIdx !== -1) ? clickedIdx : 0;
                        } catch (_) { State.startBtnClickedSectionIdx = 0; }
                        Logger.success('已触发图文开始（JS 等价操作）');
                        return;
                    } else {
                        // 【续学识别】课程已越过起始页（断点续学 / 站点自动进到中段，如直接落在
                        // page-aq01 答题页）：此时不应反复尝试"开始"，而是视为已开始，
                        // 置 hasClickedStart=true 后继续走翻页/答题/视频逻辑，避免无限刷
                        // "[图文开始] 暂无法 JS 触发开始 (已尝试 N 次)"。
                        const midCourse = !!(activeSection && !(
                            activeSection.classList.contains('page-start') ||
                            /(^|\s)page-start(\s|$)/.test(activeSection.className || '')
                        ));
                        if (midCourse) {
                            State.hasClickedStart = true;
                            State.startBtnClickTime = Date.now();
                            State.startBtnRetryCount = 0;
                            State._startBtnWatched = 'clicked';
                            try {
                                const validSections = Array.from(_pageItems || []).filter(s =>
                                    !s.classList.contains('page-start') && !s.classList.contains('page-end')
                                );
                                const clickedIdx = validSections.findIndex(s => s.classList.contains('page-active'));
                                State.startBtnClickedSectionIdx = (clickedIdx !== -1) ? clickedIdx : 0;
                            } catch (_) { State.startBtnClickedSectionIdx = 0; }
                            try { Logger.info('识别到课程已越过起始页（续学/自动进中段），视为已开始，直接继续'); } catch (_) {}
                            // 不 return：继续向下走翻页/答题/视频逻辑
                        } else {
                            // 【无开始按钮模板判定】无 .page-start 起始页，但已存在翻页/答题按钮
                            // （新版编号页模板：btn-next / btn-aq* / page-reciprocal）——课程没有
                            // "开始"步骤，直接进入正文翻页。此时不应反复报 start-fail 噪音
                            // （真实日志：图文翻页 4→13/26 正常，同时持续误报"暂无法 JS 触发开始"）。
                            let noStartTemplate = false;
                            try {
                                noStartTemplate = !!doc.querySelector(
                                    '.btn-next, [class*="btn-next"], .btn-aq, .btn-at, .btn-af, .btn-aq-n, .btn-aq-y, .page-reciprocal, [class*="page-reciprocal"]'
                                );
                            } catch (_) {}
                            if (noStartTemplate) {
                                State.hasClickedStart = true;
                                State.startBtnRetryCount = 0;
                                State.startBtnClickTime = State.startBtnClickTime || Date.now();
                                State._startBtnWatched = 'clicked';
                                try { Logger.info('识别到无开始按钮的新版图文模板（btn-next 直接翻页），视为已开始'); } catch (_) {}
                                // 不 return：继续向下走翻页/答题/视频逻辑
                            } else {
                                // 仍失败：只重置 retry 计数，避免反复报警告，不再 DOM 查找按钮或注册 DOMWatcher
                                State.startBtnRetryCount = Math.min(State.maxQuizAttempts || 999, (State.startBtnRetryCount || 0) + 1);
                                try { GraphicJsAdapter.diagPageStructure(doc, 'start-fail'); } catch (_) {}
                                try { Logger.debug(`[图文开始] 暂无法 JS 触发开始 (已尝试 ${State.startBtnRetryCount} 次)`); } catch (_) {}
                                return;
                            }
                        }
                    }
                }
            }

            // 【图文带 class 模糊 btnClick 元素兜底点击】
            // 独立于开始按钮逻辑：无论 hasClickedStart 状态，每次进入图文处理逻辑都会执行
            // 同一 section 内每个匹配元素只点一次（用 data-shuake-btnclicked 标记）
            // section 切换后，新 section 内的元素没标记，会被再次处理
            try {
                const btnClickSelector = '[class*="btnClick"], [class*="btn-click"], [class*="btn_click"], [class*="BtnClick"], [class*="Btn-Click"]';
                const btnClickScope = activeSection || doc;
                let btnClickEls = [];
                try { btnClickEls = btnClickScope.querySelectorAll(btnClickSelector); } catch (_) {}
                if (btnClickEls && btnClickEls.length > 0) {
                    let clickedCount = 0;
                    for (const el of btnClickEls) {
                        try {
                            if (!el || el.nodeType !== 1) continue;
                            // 已点击过则跳过（同 section 内不重复点击）
                            if (el.getAttribute && el.getAttribute('data-shuake-btnclicked') === '1') continue;
                            if (el.disabled) continue;
                            // 隐藏元素跳过
                            if (typeof el !== 'undefined' && el && typeof el.offsetParent !== 'undefined' && el.offsetParent === null) {
                                try {
                                    // 【兜底】极端情况下 el 非 Element（如 querySelector 返回注释/SVG 异常节点），
                                    // getComputedStyle 会抛 TypeError。先做 instanceof/节点类型强校验再调用。
                                    if (typeof el.nodeType !== 'number' || el.nodeType !== 1) continue;
                                    const ds = getComputedStyle(el).display;
                                    if (ds === 'none') continue;
                                } catch (_) { continue; }
                            }
                            // 排除 page-start / page-end 容器自身（无 btnClick 标记的占位 section）
                            const elCls = (el.className || '');
                            if (!/(^|\s)(btnClick|btn-click|btn_click|BtnClick|Btn-Click)/.test(elCls) &&
                                /(^|\s)page-(start|end)(\s|$)/.test(elCls)) continue;
                            // 【Tier1 优先】元素 class 同时含 btn-next：交予 Tier1（读取 build JS 调站点函数）
                            // 处理，btnClick 块不再抢点/标记，避免同 cycle 双重动作（点击+强制翻页互相干扰）
                            if (GraphicAdapter.fuzzyNextClass(elCls)) {
                                continue;
                            }
                            // 标记已点击（同一 section 不再点）
                            try { el.setAttribute('data-shuake-btnclicked', '1'); } catch (_) {}
                            // 复用 clickStartButton 的激进点击（jQuery / 原生 / dispatch 全套）
                            GraphicAdapter.clickStartButton(el);
                            clickedCount += 1;
                        } catch (_) {}
                    }
                    if (clickedCount > 0) {
                        try { Logger.success(`[btnClick 兜底] section 内点击了 ${clickedCount} 个 class 模糊带 btnClick 的元素`); } catch (_) {}
                    }
                }
            } catch (e) {
                try { Logger.debug(`btnClick 兜底异常: ${e.message}`); } catch (_) {}
            }

            // 【图文页面 class 模糊匹配 btn-next 兜底点击】
            // 仅在图文页面生效（视频页面有专门的视频完成判定，不能提前翻页）
            // 扫描所有 section（不限于 page-active）的 [class*="btn-next"] / next-btn / next_btn 元素
            // 同一元素只点一次（用 data-shuake-nextclicked 标记）
            // 跳过：page-next 容器、prev 类按钮、hidden 元素
            try {
                // 判定是否为图文页：当前 active section 不是 page-video / page-WH
                let isGraphicPage = false;
                try {
                    const activeSecForBtnNext = activeSection;
                    if (activeSecForBtnNext) {
                        isGraphicPage = !activeSecForBtnNext.classList.contains('page-video') &&
                            !GraphicAdapter.hasRealVideoSource(activeSecForBtnNext);
                    }
                } catch (_) {}
                if (isGraphicPage) {
                    // 模糊匹配：大小写不敏感 [class*="next" i] 覆盖 btnNext / NEXT / btn_next 等变体，
                    // 具体是否命中再由 fuzzyNextClass 归一化判定（btn-next / btn_next / btnNext /
                    // next-btn / next_btn / nextBtn / page-next 等全部识别）
                    const btnNextSelector = '[class*="next" i]';
                    const btnNextScope = doc;
                    const normCls = (s) => String(s || '').toLowerCase().replace(/[-_\s]+/g, '·');
                    const isNumVariant = (c) => /btn·?next\d|next·?btn\d/.test(normCls(c));   // btn-next2 等编号叠加层
                    const isPlainNextCls = (c) => GraphicAdapter.fuzzyNextClass(c) && !isNumVariant(c);
                    const isPageNextContainer = (c) => {
                        const n = normCls(c);
                        return /(?:^|·)page·?next/.test(n) && !/(?:^|·)btn·?next/.test(n) && !/(?:^|·)next·?btn/.test(n);
                    };
                    let btnNextEls = [];
                    try { btnNextEls = Array.from(btnNextScope.querySelectorAll(btnNextSelector)); } catch (_) {}
                    if (btnNextEls && btnNextEls.length > 0) {
                        // 【新增】预筛：若存在"纯 btn-next"（非编号），则编号变体（如 btn-next26）一律跳过。
                        // 本站的 btn-next26 是固定叠加层，点击会导致课程进度被重置回中间页。
                        let hasPlainBtnNext = false;
                        try {
                            hasPlainBtnNext = btnNextEls.some(el => el && el.nodeType === 1 &&
                                isPlainNextCls(el.className || ''));
                        } catch (_) {}
                        let nextClicked = 0;
                        for (const el of btnNextEls) {
                            try {
                                if (!el || el.nodeType !== 1) continue;
                                const elCls = (el.className || '');
                                // 非 btn-next 家族（含 page-next 之外的普通 next 元素）直接跳过
                                if (!GraphicAdapter.fuzzyNextClass(elCls)) continue;
                                // 【Tier1 优先】active section 内的 .btn-next 交予 Tier1（读取 build JS 调站点函数）处理，
                                // 兜底不再抢点，避免同 cycle"点击+强制翻页"双重动作互相干扰；此处不标记，
                                // 让 Tier1 在本轮后续即可接管（走页面 jQuery trigger 调用站点函数）。
                                try {
                                    const _actSec = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                                    if (_actSec && _actSec.contains(el)) continue;
                                } catch (_) {}
                                // 【新增】纯 btn-next 存在时跳过编号变体（避免点击导致进度重置）
                                if (hasPlainBtnNext && isNumVariant(elCls)) continue;
                                // 同一元素只点一次
                                if (el.getAttribute && el.getAttribute('data-shuake-nextclicked') === '1') continue;
                                // 跳过 page-next 容器（不是按钮）
                                if (isPageNextContainer(elCls)) continue;
                                // 跳过包含 prev 的按钮（避免上一页）
                                if (/(^|\s)(prev|previous|back)(\s|-|$)/.test(elCls) ||
                                    /prev|previous|back/.test(elCls.replace(/(btn-next|next-btn|next_btn)/gi, ''))) continue;
                                // 跳过 page-end 容器
                                if (/(^|\s)page-end(\s|$)/.test(elCls) && !isPlainNextCls(elCls)) continue;
                                // 跳过 disabled 按钮
                                if (el.disabled) continue;
                                // 跳过真正隐藏的元素
                                if (typeof el !== 'undefined' && el && typeof el.offsetParent !== 'undefined' && el.offsetParent === null) {
                                    try {
                                        if (typeof el.nodeType !== 'number' || el.nodeType !== 1) continue;
                                        const ds = getComputedStyle(el).display;
                                        if (ds === 'none') continue;
                                    } catch (_) { continue; }
                                }
                                // 【新增】追加可见性过滤：无布局盒 / visibility:hidden 也跳过，
                                // 避免把 18 个（含隐藏/固定定位）btn-next 全部点击一遍造成翻页干扰
                                try {
                                    if (!el || typeof el.nodeType !== 'number' || el.nodeType !== 1) continue;
                                    if (typeof el.getClientRects === 'function' && el.getClientRects().length === 0) continue;
                                    if (getComputedStyle(el).visibility === 'hidden') continue;
                                } catch (_) { continue; }
                                // 标记已点击（同一元素不重复点击，避免循环翻页）
                                try { el.setAttribute('data-shuake-nextclicked', '1'); } catch (_) {}
                                // 复用 clickStartButton 的激进点击（jQuery / 原生 / dispatch 全套）
                                GraphicAdapter.clickStartButton(el);
                                nextClicked += 1;
                                try { Logger.info(`[btn-next 兜底] 点击: <${el.tagName.toLowerCase()} class="${elCls.substring(0, 60)}">`); } catch (_) {}
                            } catch (_) {}
                        }
                        if (nextClicked > 0) {
                            try { Logger.success(`[btn-next 兜底] 共点击了 ${nextClicked} 个 class 模糊带 btn-next 的元素`); } catch (_) {}
                        }
                    }
                }
            } catch (e) {
                try { Logger.debug(`btn-next 兜底异常: ${e.message}`); } catch (_) {}
            }

            // 【图文页面 xgplayer-icon-play 独立点击兜底 + 16 倍速】
            // 每个视频容器（.xgplayer / <video>）只点一次，用 data-shuake-playcontainer-clicked 标在容器上
            // section 切换后，新 section 出现的新视频容器没标记，会被再次处理
            // 同一视频容器内的任何播放图标（xgplayer-icon-play / xgplayer-play）都触发一次
            // 紧接着设置 video.playbackRate = 16 / xgplayer.playbackRate = 16
            try {
                // 兜底：扫描所有 class 含 xgplayer-icon-play / xgplayer-play 的元素
                const playIconSelector = '.xgplayer-icon-play, .xgplayer-play, [class*="xgplayer-icon-play"], [class*="xgplayer-play"]';
                const playScope = activeSection || doc;
                let playEls = [];
                try { playEls = playScope.querySelectorAll(playIconSelector); } catch (_) {}

                // 也检查没有图标但视频被暂停的情况：通过 video.paused 判断
                let needRateEls = [];
                try {
                    const allVideos = playScope.querySelectorAll('.xgplayer, video');
                    for (const v of allVideos) {
                        if (v.getAttribute && v.getAttribute('data-shuake-16x-clicked') === '1') continue;
                        needRateEls.push(v);
                    }
                } catch (_) {}

                if (playEls && playEls.length > 0) {
                    let playClicked = 0;
                    for (const el of playEls) {
                        try {
                            if (!el || el.nodeType !== 1) continue;
                            // 找到所属的视频容器（.xgplayer / <video>）
                            const videoContainer = el.closest('.xgplayer') ||
                                (() => { try { return el.parentElement && el.parentElement.querySelector('video'); } catch (_) { return null; } })() ||
                                (() => { try { return el.closest('video'); } catch (_) { return null; } })();
                            // 同视频容器已点过则跳过
                            if (videoContainer && videoContainer.getAttribute && videoContainer.getAttribute('data-shuake-playcontainer-clicked') === '1') continue;
                            // 隐藏元素跳过（但视频暂停时的图标可能遮挡，需要绕过 offsetParent 检测）
                            // 直接尝试点击，不强制要求可见（xgplayer 暂停时图标可能是父级 div 控制的）
                            // 标记容器级别已点击
                            if (videoContainer) {
                                try { videoContainer.setAttribute('data-shuake-playcontainer-clicked', '1'); } catch (_) {}
                            }
                            try { Logger.info(`[xgplayer-icon-play 兜底] 点击播放图标: <${el.tagName.toLowerCase()} class="${(el.className||'').toString().substring(0,60)}">`); } catch (_) {}
                            DOMUtils.simulateClick(el);
                            playClicked += 1;
                        } catch (_) {}
                    }
                    if (playClicked > 0) {
                        try { Logger.success(`[xgplayer-icon-play 兜底] section 内点击了 ${playClicked} 个播放图标`); } catch (_) {}
                    }
                }

                // 倍速：对每个未设置的视频容器设置 playbackRate（真实播放模式=2x，跳过模式=16x）
                // 这里遍历所有 .xgplayer / <video>，包括没出现播放图标的（可能已经在播了）
                if (needRateEls.length > 0) {
                    const targetRate = CONFIG.realVideoPlay
                        ? (CONFIG.videoPlaybackRate > 0 ? CONFIG.videoPlaybackRate : 2)
                        : 16;
                    const rateLabel = CONFIG.realVideoPlay ? '2x' : '16x';
                    let rateApplied = 0;
                    for (const container of needRateEls) {
                        try {
                            if (!container || container.nodeType !== 1) continue;
                            // 容器可能是 .xgplayer 或 <video>
                            let videoEl = null;
                            if (container.tagName === 'VIDEO') {
                                videoEl = container;
                            } else {
                                try { videoEl = container.querySelector('video'); } catch (_) {}
                            }
                            if (!videoEl) continue;

                            // 标记已设置倍速
                            try { container.setAttribute('data-shuake-16x-clicked', '1'); } catch (_) {}

                            // 方式 A：直接设置 video.playbackRate（最多重试 30 次）
                            let rateSet = false;
                            try {
                                videoEl.playbackRate = targetRate;
                                rateSet = true;
                            } catch (_) {}

                            // 方式 B：通过 xgplayer 实例设置
                            try {
                                if (!rateSet && container.id && window.xgplayerMap) {
                                    const xp = window.xgplayerMap[container.id];
                                    if (xp && typeof xp.playbackRate !== 'undefined') {
                                        try { xp.playbackRate = targetRate; rateSet = true; } catch (_) {}
                                    }
                                }
                            } catch (_) {}

                            // 方式 C：用 get(0) 拿 jQuery 对象设置
                            try {
                                if (!rateSet && typeof window.$ === 'function') {
                                    const $v = window.$(videoEl);
                                    if ($v && $v.length) {
                                        $v[0].playbackRate = targetRate;
                                        rateSet = true;
                                    }
                                }
                            } catch (_) {}

                            // 方式 D：起一个短轮询，确保 video 开始播放后立即设置倍速
                            // 因为有些播放器的 playbackRate 只在 play 后能改
                            if (rateSet) {
                                rateApplied += 1;
                                let retries = 0;
                                const setRateOnPlay = () => {
                                    try {
                                        if (videoEl && !videoEl.paused && videoEl.playbackRate !== targetRate) {
                                            videoEl.playbackRate = targetRate;
                                        }
                                        if (container && container.id && window.xgplayerMap) {
                                            const xp = window.xgplayerMap[container.id];
                                            if (xp && xp.playbackRate !== targetRate) {
                                                try { xp.playbackRate = targetRate; } catch (_) {}
                                            }
                                        }
                                    } catch (_) {}
                                    retries += 1;
                                    if (retries < 30 && (!videoEl || videoEl.playbackRate !== targetRate)) {
                                        setTimeout(setRateOnPlay, 200);
                                    }
                                };
                                setTimeout(setRateOnPlay, 100);
                                try { Logger.success(`[16x 兜底] 已为视频容器设置 16x 倍速（重试中）`); } catch (_) {}
                            }
                        } catch (_) {}
                    }
                    if (rateApplied > 0) {
                        try { Logger.success(`[倍速兜底] 申请了 ${rateApplied} 个视频容器的 ${rateLabel} 倍速`); } catch (_) {}
                    }
                }
            } catch (e) {
                try { Logger.debug(`xgplayer-icon-play/倍速兜底异常: ${e.message}`); } catch (_) {}
            }

            // 5s 兜底：按钮消失时，只有 section 未切换才重置
            if (State.hasClickedStart && State.startBtnClickTime && State.startBtnRetryCount < 3) {
                // 【守卫】仅在仍处于起始页（page-start 激活段）时才执行开始按钮兜底；
                // 已进入图文/视频正文的中间页不再触发，避免中途反复"已点击开始按钮"+6s 重试噪音
                let isOnStartPage = false;
                try {
                    const curAct = _activeSection;
                    isOnStartPage = !!(curAct && curAct.classList && curAct.classList.contains('page-start'));
                } catch (_) {}
                if (!isOnStartPage) {
                    // 中间页：只清开始按钮"重试计时"，但绝不能把 hasClickedStart 重置为 false——
                    // 否则下一轮 !hasClickedStart 会重新进入开始逻辑，配合站点 .btn-start 的
                    // BtnFn（无条件给 page-0 加 page-active）造成 page-0 ↔ page-N 死循环
                    // （日志特征：section 切换 1->0 / native-btn-start-click 每轮循环）。
                    State.hasClickedStart = true;
                    State.startBtnClickTime = null;
                    State.startBtnRetryCount = 0;
                } else {
                const elapsed = Date.now() - State.startBtnClickTime;
                if (elapsed >= 5000) {
                    try {
                        // 再次尝试找按钮（可能只是被遮盖）
                        const activeSectionForStart = _activeSection;
                        const startBtn = GraphicAdapter.findStartButton(doc, activeSectionForStart);
                        if (startBtn) {
                            State.startBtnRetryCount += 1;
                            Logger.debug(`开始按钮点击后 ${Math.round(elapsed/1000)}s 未跳转，触发兜底重试 (${State.startBtnRetryCount}/3)`);
                            GraphicAdapter.clickStartButton(startBtn);
                            State.startBtnClickTime = Date.now();
                            State._startBtnWatched = 'clicked';
                            // 重试时重新记录当前 section 索引
                            try {
                                const validSections = _validSections;
                                const clickedIdx = validSections.findIndex(s => s.classList.contains('page-active'));
                                State.startBtnClickedSectionIdx = (clickedIdx !== -1) ? clickedIdx : 0;
                            } catch (_) {}
                            return;
                        } else {
                            // 按钮不存在：检查 section 是否已切换
                            // 获取当前有效 section 索引（排除 page-start）
                            let currentIdx = -1;
                            try {
                                const validSections = _validSections;
                                currentIdx = validSections.findIndex(s => s.classList.contains('page-active'));
                            } catch (_) {}

                            // section 已切换 → 点击成功，不需要重置
                            if (State.startBtnClickedSectionIdx !== null && currentIdx !== -1 &&
                                currentIdx !== State.startBtnClickedSectionIdx) {
                                try { Logger.debug(`开始按钮已消失但 section 已切换 (${State.startBtnClickedSectionIdx} → ${currentIdx})，翻页成功`); } catch (_) {}
                                // 已切换就不重置了，让后续的"section 切换检测"去重置所有状态
                            } else {
                                // section 仍未切换 → 重置，准备重试或触发强制翻页
                                Logger.warning('开始按钮已消失且 section 未切换，重置状态');
                                State.hasClickedStart = false;
                                State.startBtnClickTime = null;
                                // 释放 sentinel，允许重新注册 DOMWatcher
                                State._startBtnWatched = false;
                            }
                        }
                    } catch (e) {
                        try { Logger.debug(`开始按钮重试异常: ${e.message}`); } catch (_) {}
                    }
                }
                } // else 结束：仅在起始页时才执行开始按钮兜底
            }

            // 重试已达上限
            if (State.hasClickedStart && State.startBtnRetryCount >= 3 && State.startBtnClickTime) {
                const elapsed = Date.now() - State.startBtnClickTime;
                if (elapsed >= 5000) {
                    try {
                        // 【守卫】仅起始页生效：中间页不执行"开始按钮重试已达上限强制跳转"，
                        // 否则强制翻页（切 class）会被站点 JS 回退，导致 8↔18 死循环
                        let onStartPage2 = false;
                        try {
                            const ca2 = _activeSection;
                            onStartPage2 = !!(ca2 && ca2.classList && ca2.classList.contains('page-start'));
                        } catch (_) {}
                        if (!onStartPage2) {
                            State.hasClickedStart = true;
                            State.startBtnClickTime = null;
                            State.startBtnRetryCount = 0;
                            try { Logger.debug('开始按钮重试已达上限但不在起始页，跳过强制翻页'); } catch (_) {}
                        } else {
                        // 检测是否为最后一页且无法跳转（课程结束）
                        const isLastPage = GraphicAdapter.isLastPage(doc);
                        const endBackEl = doc.querySelector('.page-end-back, [class*="page-end-back"]');
                        // 只有【可见】的结束页按钮才算数，避免中间页误报"课程完成"
                        const hasEndBackBtn = !!(endBackEl && DOMUtils.isVisible(endBackEl));

                        Logger.debug(`检测结束页: isLastPage=${isLastPage}, hasEndBackBtn=${hasEndBackBtn}`);

                        if (hasEndBackBtn && endBackEl) {
                            Logger.warning(`检测到可见 page-end-back 元素: ${endBackEl.className}`);
                        }
                        
                        // 只有【可见】的结束页按钮 + isLastPage 同时成立才算课程真正结束，
                        // 避免中间页（如第 8/27 页）因检测到 DOM 中的隐藏结束标记而误报"图文完成"
                        if (isLastPage && hasEndBackBtn) {
                            Logger.warning('检测到最后一页或结束页标记，标记图文完成');
                            State.graphicCompleted = true;
                            State.hasClickedStart = false;
                            State.startBtnClickTime = null;
                            State.startBtnRetryCount = 0;
                            State.startBtnClickedSectionIdx = null;
                            State._startBtnWatched = false;
                            
                            // 尝试点击返回按钮
                            try {
                                const backBtn = doc.querySelector('.page-end-back, .back-list, [class*="page-end-back"], [class*="back-list"]');
                                if (backBtn) {
                                    Logger.debug(`找到返回按钮: ${backBtn.className}, visible=${backBtn.offsetParent !== null}`);
                                    DOMUtils.simulateClick(backBtn);
                                    Logger.success('已点击返回按钮');
                                } else {
                                    Logger.debug('未找到返回按钮');
                                }
                            } catch (e) {
                                Logger.debug(`点击返回按钮异常: ${e.message}`);
                            }
                            
                            setTimeout(() => {
                                try { this.requestInject(); } catch (e) {}
                            }, CONFIG.injectDelay);
                            return;
                        }
                        
                        Logger.warning('开始按钮重试已达上限，强制跳转下一页');
                        const advanced = GraphicAdapter.forceAdvancePage(doc, true);
                        if (advanced) {
                            State.hasClickedStart = false;
                            State.startBtnClickTime = null;
                            State.startBtnRetryCount = 0;
                            State.startBtnClickedSectionIdx = null;
                            State._startBtnWatched = false;
                            // 标记翻页中，等待 section 切换检测解锁
                            State.isPageTurning = true;
                            State.pageTurnTriggerTime = Date.now();
                            State.pageTurnTriggerSelector = 'forceAdvancePage';
                        }
                        State.startBtnClickTime = Date.now();
                        return;
                        } // else 结束：仅在起始页时才执行开始按钮重试强制跳转
                    } catch (e) {
                        try { Logger.debug(`强制翻页异常: ${e.message}`); } catch (_) {}
                    }
                }
            }

            // 视频页直接强制跳过
            try {
                // 翻页中就不再触发，避免重复点击导致一直跳过
                if (State.isPageTurning && !GraphicAdapter.hasPageTurned(doc)) {
                    Logger.debug('翻页中，跳过视频页跳过逻辑');
                    return;
                }
                const activeSectionForVideo = _activeSection;
                if (activeSectionForVideo && (
                    activeSectionForVideo.classList.contains('page-video') ||
                    ((activeSectionForVideo.querySelector('.xgplayer, #xgplayer, [class*="xgplayer"]') || activeSectionForVideo.querySelector('video')) && GraphicAdapter.hasRealVideoSource(activeSectionForVideo))
                )) {
                    // 先交给 handleEmbeddedVideo 接管：点播放 / 快进（触发站点 timeupdate 自动切页）。
                    // 不能直接 return，否则永远到不了下方 handleEmbeddedVideo，视频永不完成。
                    try { if (typeof this.handleEmbeddedVideo === 'function') this.handleEmbeddedVideo(doc); } catch (_) {}
                    // 若视频尚未播放完成（含正在播放、尚未结束），不要在此处强行翻页
                    if (!State.videoCompleted) {
                        // 卡死超时：自动播放被拦截（play() 被拒）/ duration 未加载导致快进无效时，
                        // 视频页停留过久 → 强制完成并翻页，避免永久卡死（配合 start 兜底守卫杜绝拉回循环）。
                        const _vt = State.videoPlayStartTime || 0;
                        if (_vt && (Date.now() - _vt > 15000)) {
                            State.videoCompleted = true;
                            try { Logger.warning('图文内嵌视频超时未完成（自动播放被拦截？），强制完成并翻页'); } catch (_) {}
                        } else {
                            try { Logger.debug('视频页跳过：视频尚未完成，跳过强制翻页'); } catch (_) {}
                            return;
                        }
                    }
                    Logger.info('视频页强制跳过（已完成）');
                    const nextBtnVideo = GraphicAdapter.findNextIn(activeSectionForVideo);
                    let clicked = false;
                    if (nextBtnVideo) {
                        try {
                            if (nextBtnVideo.tagName === 'IMG') {
                                const parentVideo = nextBtnVideo.closest('a, button, div[onclick], [role="button"]');
                                DOMUtils.simulateClick(parentVideo || nextBtnVideo);
                            } else {
                                DOMUtils.simulateClick(nextBtnVideo);
                            }
                            clicked = true;
                        } catch (e) {}
                    }
                    if (!clicked) {
                        try {
                            if (GraphicAdapter.forceAdvancePage(doc)) {
                                clicked = true;
                            }
                        } catch (_) {}
                    }
                    if (!clicked) {
                        Logger.warning('视频页无下一页按钮');
                    }
                    return;
                }
            } catch (e) {
                try { Logger.debug(`视频页跳过异常: ${e.message}`); } catch (_) {}
            }

            // ===== 结束：视频页互斥跳过图文链路的关闭括号 =====
            // skipGraphicFlow=true 时：跳过 13657-14230 整个图文 Loader/开始/翻页/答题/结束流程，
            // 避免视频页误打印"已点击开始按钮"或强行翻页/点图文按钮干扰视频进度。
            }  // else 分支闭合（对应 13655 行 if (skipGraphicFlow) {} else {）

            // 考试页面 AI 答题
            try {
                if (AIAnswer.isExamPage(doc) && CONFIG.enableAIAnswer) {
                    this.sendStatus('AI 答题中...');
                    AIAnswer.processExamPage(doc);
                    return;
                }
            } catch (e) {
                try { Logger.debug(`AI 答题异常: ${e.message}`); } catch (_) {}
            }

            // 视频页面处理
            let videoInfo = null;
            let videoType = null;
            let iframeDoc = doc;
            let iframeWin = null;
            try {
                videoInfo = VideoAdapter.detectInIframe();
                videoType = videoInfo ? videoInfo.type : null;
                if (videoInfo) {
                    iframeDoc = videoInfo.doc || doc;
                    iframeWin = videoInfo.win || null;
                }
                if (!videoType) {
                    videoType = VideoAdapter.detect(doc);
                    iframeDoc = doc;
                    iframeWin = window;
                }
            } catch (e) {
                try { Logger.debug(`视频检测异常: ${e.message}`); } catch (_) {}
            }

            if (videoType) {
                State.isVideoPage = true;
                State.graphicCompleted = false;
                State.injectExecuted = false;
                this.sendStatus(`播放视频中 (${videoType})${CONFIG.realVideoPlay ? ' · 真实' + (CONFIG.videoPlaybackRate > 0 ? CONFIG.videoPlaybackRate : 2) + 'x' : ''}`);

                try {
                    const pageVideo = doc.querySelector('.page-WH.page-video, section.page-WH.page-video');
                    if (pageVideo) {
                        Logger.debug('检测到 page-WH page-video 页面类型');
                        const player = VideoAdapter.getPlayer(videoType, iframeDoc, iframeWin);
                        if (player && typeof player.on === 'function' && !State.videoCompleted) {
                            try {
                                player.on('ended', () => {
                                    Logger.success('page-WH 视频播放结束');
                                    try { this.handleVideoComplete(); } catch (e) {}
                                });
                            } catch (e) {}
                        }
                        setTimeout(() => {
                            try {
                                const playBtn = doc.querySelector('.vjs-big-play-button');
                                if (playBtn && playBtn.offsetParent !== null) {
                                    DOMUtils.simulateClick(playBtn);
                                    Logger.debug('已点击 vjs-big-play-button');
                                }
                            } catch (e) {}
                        }, 500);
                    }
                } catch (e) {
                    try { Logger.debug(`page-WH 处理异常: ${e.message}`); } catch (_) {}
                }

                if (!State.videoPlayStartTime) {
                    State.videoPlayStartTime = Date.now();
                    Logger.debug(`记录视频开始时间: ${State.videoPlayStartTime}`);
                    // 【上报计时】视频开始播放即开始计时，完成上报时 duration 反映真实播放时长
                    try { StudyReporter.ensureStarted(); } catch (_) {}
                }

                let player = null;
                try {
                    player = VideoAdapter.getPlayer(videoType, iframeDoc, iframeWin);
                } catch (e) {
                    try { Logger.debug(`getPlayer 异常: ${e.message}`); } catch (_) {}
                }

                if (player) {
                    if (CONFIG.realVideoPlay) {
                        // 真实播放模式：先确保触发播放，再判断是否完成。
                        // 【顺序修复】原逻辑 `if (isCompleted)` 优先：视频加载初期 duration 短暂异常时
                        // isCompleted 会误判 true，直接进入 handleVideoComplete，导致 play() 从未被调用、
                        // iframe 播放器从不开始播放（表现为"真实播放 0s 就等待完成"）。
                        // 【ended 事件·幂等注册】视频真实播完（contrib-hls 触发 ended）→ 直接完成，
                        // 不依赖 isCompleted 比例判定（contrib-hls duration 可能虚低，比例不可靠）。
                        if (videoType === 'videojs' && player && typeof player.on === 'function' && !player.__skEndedBound) {
                            player.__skEndedBound = true;
                            try {
                                player.on('ended', () => {
                                    try { Logger.success('VideoJS 真实播放结束（ended 事件）'); } catch (_) {}
                                    try { this.handleVideoComplete(); } catch (_) {}
                                });
                            } catch (_) {}
                        }
                        try {
                            const rate = CONFIG.videoPlaybackRate > 0 ? CONFIG.videoPlaybackRate : 2;
                            VideoAdapter.applyRate(videoType, player, rate);
                            // 【播放触发·内联】强力触发 iframe 内播放器真正开始播放：
                            // videojs：实例 play（被拦截→静音重试）+ 点击 big-play-button + 底层 <video> 元素 play 兜底；
                            // 其它播放器：仅在暂停时播放。
                            if (videoType === 'videojs' && player && typeof player.play === 'function') {
                                // 【video.js 6.x 兼容】play() 不返回 Promise（无法 catch 自动播放拦截），
                                // 统一先 muted(true) 再 play()：静音后浏览器允许自动播放，确保真实播放必然开始。
                                try { if (typeof player.muted === 'function') player.muted(true); } catch (_) {}
                                try {
                                    const p0 = player.play();
                                    if (p0 && typeof p0.catch === 'function') {
                                        p0.catch(() => {
                                            try { if (typeof player.muted === 'function') player.muted(true); } catch (_) {}
                                            try { const p1 = player.play(); if (p1 && typeof p1.catch === 'function') p1.catch(() => {}); } catch (_) {}
                                            try { Logger.debug('视频自动播放被拦截，已静音重试播放'); } catch (_) {}
                                        });
                                    }
                                } catch (_) {
                                    try { if (typeof player.muted === 'function') player.muted(true); } catch (_) {}
                                    try { const p1 = player.play(); if (p1 && typeof p1.catch === 'function') p1.catch(() => {}); } catch (_) {}
                                }
                            } else if (player && VideoAdapter.isPaused(videoType, player)) {
                                try { VideoAdapter.play(videoType, player); } catch (_) {}
                            }
                            // 点击 videojs 大播放按钮（首次播放需点击才能触发）
                            try {
                                if (videoType === 'videojs' && player && typeof player.el === 'function') {
                                    const rootEl = player.el();
                                    const scope = (rootEl && rootEl.ownerDocument) ? rootEl.ownerDocument : document;
                                    const bigBtn = scope.querySelector('.vjs-big-play-button, .vjs-play-control');
                                    if (bigBtn && (bigBtn.offsetParent !== null || (bigBtn.style && bigBtn.style.display !== 'none'))) {
                                        DOMUtils.simulateClick(bigBtn);
                                        try { Logger.debug('已点击 videojs big-play-button 触发播放'); } catch (_) {}
                                    }
                                }
                            } catch (_) {}
                            // 底层 <video> 元素兜底（videojs muted 未生效时直接操作原生元素）
                            try {
                                if (videoType === 'videojs' && player && typeof player.el === 'function') {
                                    const rootEl = player.el();
                                    const vEl = rootEl ? rootEl.querySelector('video') : null;
                                    if (vEl && typeof vEl.play === 'function') {
                                        vEl.play().catch(() => {
                                            try { vEl.muted = true; vEl.play().catch(() => {}); } catch (_) {}
                                        });
                                    }
                                }
                            } catch (_) {}
                            const progress = VideoAdapter.getProgress(videoType, player);
                            this.sendProgress(progress);
                            try { Logger.debug(`[真实播放] ${videoType} ${rate}x 播放中: ${Math.min(100, Math.round(progress || 0))}%`); } catch (_) {}
                        } catch (e) {
                            try { Logger.debug(`真实播放设置异常: ${e.message}`); } catch (_) {}
                        }
                        if (VideoAdapter.isCompleted(videoType, player)) {
                            try { this.handleVideoComplete(); } catch (e) {}
                        }
                        // 【真实播放防卡死·停滞检测】不按固定时长强制完成（避免视频还在真实播放就被提前跳走）：
                        // 仅当视频"实际卡住"（current 长时间无增长）才强制完成。
                        // 覆盖：自动播放被拦截（current 恒 0）/ HLS 卡住 / 直播流无 ended / duration 虚低无法自然判完。
                        // 视频正常播放时 current 持续增长 → 不触发，让它真实播到结尾（ended 事件 → 完成）。
                        let _vCur = 0;
                        try {
                            if (videoType === 'videojs' && player && typeof player.currentTime === 'function') _vCur = player.currentTime();
                            else if (player && player.currentTime !== undefined) _vCur = player.currentTime;
                            else if (player && player.video) _vCur = player.video.currentTime || 0;
                        } catch (_) {}
                        const _now2 = Date.now();
                        if (State._lastVidCheck && Math.abs(_vCur - State._lastVidCur) < 0.5) {
                            State._vidStallStart = State._vidStallStart || _now2;
                        } else {
                            State._vidStallStart = null;
                        }
                        State._lastVidCur = _vCur;
                        State._lastVidCheck = _now2;
                        if (State._vidStallStart && (_now2 - State._vidStallStart) > 15000) {
                            try { Logger.warning('真实播放卡住 15s（current 无增长），强制完成并进入下一步'); } catch (_) {}
                            try { this.handleVideoComplete(); } catch (_) {}
                        }
                    } else if (VideoAdapter.isCompleted(videoType, player)) {
                        try { this.handleVideoComplete(); } catch (e) {}
                    } else {
                    try {
                        VideoAdapter.complete(videoType, player);
                        const progress = VideoAdapter.getProgress(videoType, player);
                        this.sendProgress(progress);
                    } catch (e) {
                        try { Logger.debug(`视频拉进度异常: ${e.message}`); } catch (_) {}
                    }
                }
                }   // 关闭 if (player)（真实模式重构新增嵌套层）
                return;
            }

            // ===== 图文页面处理 =====
            // 视频页互斥：skipGraphicFlow=true 时同样跳过"图文页面处理"块（section 逐页推进/结束检测）。
            if (!skipGraphicFlow) {
            try {
                // 【性能优化】主循环每 1.2s 进入一次；info 会刷屏+写存储，改为 debug。
                if (!State.graphicCompleted && !this._lastGraphicLog) {
                    Logger.debug('进入图文处理逻辑');
                    this._lastGraphicLog = true;
                }
                State.isVideoPage = false;
                State.videoCompleted = false;
                this.sendStatus('处理图文...');

                if (State.graphicCompleted) {
                    return;
                }

                if (GraphicAdapter.isEndPage(doc)) {
                    if (!State.graphicCompleted) {
                        State.graphicCompleted = true;
                        Logger.success('图文已到达结束页');

                        // --- 【JS 优先】结束页：只调 completeCourse（→ finishWxCourse），用户明确：
                        // 「有问题不要自动调用 backToList，否则无法触发结束课程 js 逻辑」
                        // 之前先 backToList() 会在 finishWxCourse 的 setTimeout 延迟前跳走，
                        // 导致站点 item.js 里 btn-next-end 绑定的结束上报完全不执行。
                        // 注意：若 Controller 之前通过 advancePage/forceAdvancePage 直接切换到 .page-end，
                        // 站点的 .btn-next-end handler 可能没被触发，导致 finishWxCourse() 不会被调用。
                        // 这里显式调用一次，确保服务端记录"已学完"。
                        try {
                            // delay 传 0：默认同步调用 finishWxCourse，不等 1000ms（用户要求"优先触发结束 JS 逻辑"、
                            // 避免跳转导致 timer 丢失）。若页面需要 Pbgfn / 切到 page-end 动画，
                            // completeCourse 内部同步会先做（class 切换 / Pbgfn / clickBase），
                            // 只有 finishWxCourse 会受 delay 控制。
                            const jsRes = GraphicJsAdapter.completeCourse(doc, 0);
                            if (jsRes.ok) {
                                try { Logger.info(`[JS优先·结束页] completeCourse → ${jsRes.reason} (delay=${jsRes.delay}ms pbgfn=${jsRes.pbgfn})`); } catch (_) {}
                            }
                        } catch (_) {}
                        // ⚠️ 不再调用 GraphicJsAdapter.backToList(doc) —— 用户要求停在结束页等待 finishWxCourse 上报完成
                        // ⚠️ 不再 DOM 兜底点击 .back-list / page-end-button —— 避免提前跳转

                        // 记录本课程已完成（跨页防重复刷）
                        try {
                            CourseInfo.parseURL();
                            CompletedCourses.add(CourseInfo.userCourseId || CourseInfo.courseId || '');
                        } catch (_) {}
                        setTimeout(() => {
                            try { this.requestInject(); } catch (e) {}
                        }, CONFIG.injectDelay);
                    } else {
                        if (!State.endPageJumpTime) {
                            State.endPageJumpTime = Date.now();
                        } else if (Date.now() - State.endPageJumpTime >= 10000) {
                            Logger.warning('结束页停留超时，跳转课程列表');
                            const courseListUrl = this.detectCourseListUrl();
                            if (courseListUrl) {
                                Logger.info(`跳转: ${courseListUrl}`);
                                try { window.top.location.href = courseListUrl; } catch (e) {}
                            } else {
                                try { window.top.location.href = 'https://weiban.mycourse.cn/'; } catch (e) {}
                            }
                        }
                    }
                    return;
                }
            } catch (e) {
                try { Logger.debug(`图文结束页处理异常: ${e.message}`); } catch (_) {}
            }

            // 视频页跳过（图文页面内的视频片段）
            try {
                // BUG FIX: activeSection 在 checkPageInternal 此作用域未定义（ReferenceError），
                // 改用方法体最外层声明的 _activeSection（站点 2500ms 定时器双活跃时已由守卫修正）。
                const activeSection = _activeSection || (typeof GraphicJsAdapter !== 'undefined' && typeof GraphicJsAdapter.activePage === 'function' ? GraphicJsAdapter.activePage(doc) : null) || null;
                const hasVideoContent = activeSection && (
                    activeSection.classList.contains('page-video') ||
                    ((activeSection.querySelector('.xgplayer, #xgplayer, [class*="xgplayer"]') || activeSection.querySelector('video')) && GraphicAdapter.hasRealVideoSource(activeSection))
                );
                if (hasVideoContent) {
                    // 视频未完成时交给 handleEmbeddedVideo / VideoAdapter 处理，不在此处直接点下一页
                    if (!State.videoCompleted) {
                        Logger.debug('图文内的视频尚未完成，跳过此处翻页，等待 handleEmbeddedVideo');
                        return;
                    }
                    Logger.info('图文内视频已完成，点击下一页');
                    const nextBtn = GraphicAdapter.findNextIn(activeSection);
                    if (nextBtn) {
                        Logger.info('点击下一页');
                        try {
                            if (nextBtn.tagName === 'IMG') {
                                const parent = nextBtn.closest('a, button, div[onclick], [role="button"]');
                                DOMUtils.simulateClick(parent || nextBtn);
                            } else {
                                DOMUtils.simulateClick(nextBtn);
                            }
                        } catch (e) {}
                        return;
                    }
                    try {
                        if (GraphicAdapter.forceAdvancePage(doc)) {
                            return;
                        }
                    } catch (e) {}
                }
            } catch (e) {
                try { Logger.debug(`视频跳过处理异常: ${e.message}`); } catch (_) {}
            }

            try {
                if (this.handleEmbeddedVideo(doc)) {
                    return;
                }
            } catch (e) {
                try { Logger.debug(`handleEmbeddedVideo 异常: ${e.message}`); } catch (_) {}
            }

            try {
                if (GraphicAdapter.handleVideoQuiz(doc)) {
                    return;
                }
            } catch (e) {
                try { Logger.debug(`handleVideoQuiz 异常: ${e.message}`); } catch (_) {}
            }

            // 获取当前页信息
            let activeIndex = -1;
            let totalSections = 0;
            try {
                // 【兼容修复】不依赖 _pageItems 缓存变量（该变量仅在 checkPageInternal 方法体内的
                // 部分作用域定义，独立函数/降级路径引用会导致 ReferenceError: _pageItems is not defined）。
                // getActiveSectionIndex/getTotalSections 不传 pageItems 时内部自行查询，行为一致。
                activeIndex = GraphicAdapter.getActiveSectionIndex(doc);
                totalSections = GraphicAdapter.getTotalSections(doc);
            } catch (e) {
                try { Logger.debug(`获取页码异常: ${e.message}`); } catch (_) {}
            }

            if (totalSections > 0 && activeIndex >= 0) {
                try {
                    const progress = ((activeIndex + 1) / totalSections) * 100;
                    this.sendProgress(progress);
                    try {
                        window.top.postMessage({
                            type: "courseInfoUpdate",
                            info: {
                                totalPage: totalSections,
                                finishedPage: activeIndex,
                                progress: Math.round(progress)
                            }
                        }, "*");
                    } catch (e) {}
                    Logger.debug(`当前页: ${activeIndex + 1}/${totalSections}`);
                } catch (e) {}
            }

            if (State.isPageTurning) {
                // 【互动页例外】滚动互动页即使 isPageTurning 未释放也要放行处理（锁可能正因互动未完成
                // 卡住；若被 return 拦截 → 永远不点 .pXX03 → 卡死）。
                let _isInter = false;
                try {
                    const _ap = doc.querySelector('.page-item.page-active');
                    if (_ap && _ap.querySelector) {
                        _isInter = !!_ap.querySelector('.p1602, .p1703, .p1803, .p1903, .p2003, [class*="p1602"], [class*="p1703"], [class*="p1803"], [class*="p1903"], [class*="p2003"]');
                    }
                } catch (_) {}
                if (!_isInter) return;
            }

            // 【滚动互动页·统一处理】（YueLia scroll() 模板 page-16~20）：活跃页含滚动触发按钮
            // （.p1602/.p1703/.p1803/.p1903/.p2003）且本页 .btn-base 未显示时，用【页面 jQuery】触发
            // 点击（scroll() 用 $(btn).click() 绑定，必须同 jQuery 实例 trigger 才触发 handler），
            // 等待 box 滚动动画完成、站点显示 .btn-base 后再翻页。
            try {
                const _actP = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                if (_actP && _actP.querySelector) {
                    const _tr = _actP.querySelector('.p1602, .p1703, .p1803, .p1903, .p2003, [class*="p1602"], [class*="p1703"], [class*="p1803"], [class*="p1903"], [class*="p2003"]');
                    let _nextVisible = false;
                    try {
                        const _nb = _actP.querySelector('.btn-next, [class*="btn-next"]');
                        if (_nb && typeof _nb.getClientRects === 'function' && _nb.getClientRects().length > 0) _nextVisible = true;
                    } catch (_) {}
                    if (_tr && !_nextVisible) {
                        const _curKey = String(_tr.className || '');
                        if (State._scrollRevealKey !== _curKey) {
                            // 优先页面 jQuery trigger（站点 scroll() 用 $(btn).click 绑定）
                            const _w = GraphicJsAdapter._pageWin();
                            const _$w = (typeof GraphicJsAdapter._$ === 'function') ? GraphicJsAdapter._$(_w) : null;
                            let _ok = false;
                            if (_$w && _tr) { try { _$w(_tr).trigger('click'); _ok = true; } catch (_) {} }
                            if (!_ok) { try { _tr.click(); } catch (_) {} }
                            try { if (typeof DOMUtils !== 'undefined' && DOMUtils.simulateClick) DOMUtils.simulateClick(_tr); } catch (_) {}
                            State._scrollRevealKey = _curKey;
                            State._scrollRevealAt = Date.now();
                            try { Logger.info('[滚动互动] 页面JS触发 ' + _curKey + ' 滚动（' + String((_actP.className || '').trim()) + '）'); } catch (_) {}
                        }
                        if (Date.now() - (State._scrollRevealAt || 0) < 2500) return;
                        if (Date.now() - (State._scrollRevealAt || 0) > 8000) {
                            State._scrollRevealKey = null;
                            try { Logger.warning('[滚动互动] 8s 未显示 btn-base，重置重试'); } catch (_) {}
                        }
                        return;
                    }
                    if (_tr && _nextVisible) {
                        State._scrollRevealKey = null;
                    }
                }
            } catch (_) {}

            // 【问答入口】活跃页有可见 btn-ce（page-19 类课后问答入口）→ 点击进入 page-aq00，
            // 不判定末页、不 completeCourse（否则跳过课后问答 → 课程不完整 → 触发风控 701）
            try {
                const _actP = doc.querySelector('.page-item.page-active, [class^="page-"].page-active, .page-active');
                if (_actP && _actP.querySelector) {
                    const _ceBtn = _actP.querySelector('[class*="btn-ce" i]');
                    if (_ceBtn) {
                        let _ceVisible = false;
                        try { _ceVisible = typeof _ceBtn.getClientRects === 'function' && _ceBtn.getClientRects().length > 0; } catch (_) {}
                        if (_ceVisible) {
                            // 【问答入口·防抖+降级】站点的 getQuestions() 异步生成课后问答页 page-aq00/01...
                            // 生成前 .btn-ce 已存在于 page-18，若反复点击而 page-aq00 未生成 → 页面不动死循环。
                            // ① 未生成时 4s 内不重复点（等 getQuestions 完成）；② 20s 仍未生成 → 判定 getQuestions
                            // 失败，降级走下方 isLastPage/completeCourse 完成课程主体（避免无限卡死）。
                            const _now = Date.now();
                            const _lastCe = State._ceClickedAt || 0;
                            const _hasAq00 = !!(doc.querySelector('.page-aq00, [class*="page-aq0"][class*="page-item"]'));
                            if (!_hasAq00 && (_now - _lastCe) < 4000) {
                                return;
                            }
                            if (!_hasAq00 && (_now - _lastCe) >= 20000) {
                                State._ceClickedAt = 0;
                                try { Logger.warn('[问答入口] getQuestions 超时未生成问答页，降级按无课后习题完成'); } catch (_) {}
                            } else {
                                State._ceClickedAt = _now;
                                try {
                                    DOMUtils.simulateClick(_ceBtn);
                                    const _$ce = GraphicJsAdapter._$(GraphicJsAdapter._pageWin());
                                    if (_$ce && _ceBtn) {
                                        try { _$ce(_ceBtn).trigger('click'); } catch (_) {}
                                        try { if (_ceBtn.click) _ceBtn.click(); } catch (_) {}
                                    }
                                    State.graphicCompleted = false;
                                    State.quizCompleted = false;
                                    try { Logger.info('[问答入口] 检测到 btn-ce，点击进入课后问答'); } catch (_) {}
                                } catch (_) {}
                                return;
                            }
                        }
                    }
                }
            } catch (_) {}

            // 最后一页
            try {
                if (GraphicAdapter.isLastPage(doc)) {
                    if (!State.graphicCompleted) {
                        // 防刷课守卫兜底（YueLia 模板 .btn-next-end 检查 pageNums>=7，不足则 alert 拦截）：
                        // 脚本 Tier2/手动翻页不触发站点 .btn-next handler → pageNums 不累计。
                        // 已到末页说明正文翻页已完成，直接补足 pageNums 让守卫放行。
                        try {
                            const _w = GraphicJsAdapter._pageWin();
                            if (_w && typeof _w.pageNums === 'number' && _w.pageNums < 7) {
                                _w.pageNums = 7;
                                try { Logger.debug('[防刷课守卫] 补足 pageNums=7 放行完成'); } catch (_) {}
                            }
                        } catch (_) {}
                        State.graphicCompleted = true;
                        Logger.success('图文完成');

                        // --- 【JS 优先】到达末页：先调用页面原生 finishWxCourse() ---
                        // 站点末页 .btn-next-end 的 jQuery handler 会移除 .page-reciprocal 的 page-active、
                        // 切换到 .page-end，再 setTimeout 1500ms 调 finishWxCourse()。
                        // 这里直接执行这两步，无需等待 DOM 点击生效。
                        try {
                            // 若当前在 reciprocal（倒数答题页）→ 先推进到 end 再 finish
                            const recRes = GraphicJsAdapter.tryFinishFromReciprocal(doc);
                            if (recRes.ok) {
                                try { Logger.info(`[JS优先·末页] reciprocal → ${recRes.reason}`); } catch (_) {}
                            } else {
                                // 已在末页内容页或 end 页：直接调 completeCourse（切换 page-end + finishWxCourse）
                                const endRes = GraphicJsAdapter.completeCourse(doc, 500);
                                if (endRes.ok) {
                                    try { Logger.info(`[JS优先·末页] completeCourse → ${endRes.reason}`); } catch (_) {}
                                }
                            }
                        } catch (_) {}

                        // 【权威完成】到达结束页：默认不直接请求完成接口（avoidDirectFinish 防风控 701），
                        // 只依赖上面 completeCourse 模拟点击 .btn-next-end → 站点原生 finishWxCourse 上报。
                        if (!CONFIG.avoidDirectFinish) {
                            try { this.completeCourseByV2(); } catch (_) {}
                        }

                        // （DOM 模拟按钮的兜底只在无原生 JS 环境时触发）
                        if (!GraphicJsAdapter.hasNativeSupport()) {
                            const endBtn = doc.querySelector('.btn-next-end, [class*="btn-end"], .page-end-button, .end-button, [class*="page-end-button"], [class*="end-button"], [class*="end_btn"], .back-list, a.back-list');
                            if (endBtn) {
                                try { DOMUtils.simulateClick(endBtn); } catch (e) {}
                                Logger.debug('点击结束按钮（DOM 兜底）');
                            }
                        }

                        setTimeout(() => {
                            try { this.requestInject(); } catch (e) {}
                        }, CONFIG.injectDelay);
                    }
                    return;
                }
            } catch (e) {
                try { Logger.debug(`最后页处理异常: ${e.message}`); } catch (_) {}
            }

            // 评论留言页（page-20 评论区）：站点"发布留言成功"才显示 .btn-base 翻页按钮。
            // 必须先发送留言再翻页（用户要求：发送留言后才能执行下面的内容）。
            try {
                if (GraphicAdapter.isCommentPage(doc)) {
                    const _actP = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                    // 判断本页 .btn-next 是否已可见（saveComment 发布成功才显示）
                    let _nextVisible = false;
                    try {
                        if (_actP) {
                            const _nb = _actP.querySelector('.btn-next, [class*="btn-next"]');
                            if (_nb && typeof _nb.getClientRects === 'function' && _nb.getClientRects().length > 0) _nextVisible = true;
                        }
                    } catch (_) {}
                    if (!State._commentSubmitted) {
                        const _ok = GraphicAdapter.submitComment(doc);
                        if (_ok) {
                            State._commentSubmitted = true;
                            State._commentSubmittedAt = Date.now();
                            try { Logger.info('[留言] 已填写内容并点击发布'); } catch (_) {}
                        }
                        return; // 等发布结果
                    }
                    // 已提交过：btn-next 未显示（发布未完成/失败）→ 等待；超时 20s 重发一次
                    if (!_nextVisible) {
                        if (Date.now() - (State._commentSubmittedAt || 0) > 20000) {
                            State._commentSubmitted = false;
                            try { Logger.warning('[留言] 发布超时，重新发布'); } catch (_) {}
                        }
                        return;
                    }
                    // btn-next 已显示（发布成功）→ 继续走下方翻页逻辑（不 return）
                }
            } catch (_) {}

            // page-16 选择互动页：完成互动（点 .box → 点 .p1602 → 1.5s 后站点显示 .btn-base）后才翻页。
            // 不能直接 trigger 隐藏的 .btn-next 跳过互动，否则站点互动状态未完成。
            try {
                if (GraphicAdapter.isPage16SelectPage(doc)) {
                    const _actP = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                    let _nextVisible = false;
                    try {
                        if (_actP) {
                            const _nb = _actP.querySelector('.btn-next, [class*="btn-next"]');
                            if (_nb && typeof _nb.getClientRects === 'function' && _nb.getClientRects().length > 0) _nextVisible = true;
                        }
                    } catch (_) {}
                    if (!_nextVisible) {
                        // 第一步：点击一个 .box（val=3）触发选择
                        if (!State._p16BoxClicked) {
                            let _box = null;
                            try { _box = _actP.querySelector('.box[val], [class*="box"][val], .box1, .box2, .box3'); } catch (_) {}
                            if (_box) {
                                try { if (typeof DOMUtils !== 'undefined' && DOMUtils.simulateClick) DOMUtils.simulateClick(_box); } catch (_) {}
                                try { _box.click(); } catch (_) {}
                                try { if (typeof $ !== 'undefined') $(_box).trigger('click'); } catch (_) {}
                                State._p16BoxClicked = true;
                                try { Logger.info('[page-16互动] 已点击选项 box'); } catch (_) {}
                            }
                            return;
                        }
                        // 第二步：点击 .p1602 完成互动（站点 1.5s 后显示 .btn-base）
                        if (!State._p16P1602Clicked) {
                            let _p1602 = null;
                            try { _p1602 = _actP.querySelector('.p1602, [class*="p1602"]'); } catch (_) {}
                            if (_p1602) {
                                try { if (typeof DOMUtils !== 'undefined' && DOMUtils.simulateClick) DOMUtils.simulateClick(_p1602); } catch (_) {}
                                try { _p1602.click(); } catch (_) {}
                                try { if (typeof $ !== 'undefined') $(_p1602).trigger('click'); } catch (_) {}
                                State._p16P1602Clicked = true;
                                try { Logger.info('[page-16互动] 已点击 p1602 确认'); } catch (_) {}
                            }
                            return;
                        }
                        // 已点完但 .btn-base 未显示（1.5s 动画中）→ 等待
                        return;
                    }
                    // .btn-next 已显示（互动完成）→ 放行翻页
                }
            } catch (_) {}

            // scroll() 滚动揭示页（YueLia 模板 page-17~20）：先点 .pXX03 触发 box 滚动，
            // 站点 1600ms 后显示 .btn-base 翻页按钮；btn-base 未显示前不能翻页。
            try {
                if (GraphicAdapter.isScrollRevealPage(doc)) {
                    const _actP = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                    let _nextVisible = false;
                    try {
                        if (_actP) {
                            const _nb = _actP.querySelector('.btn-next, [class*="btn-next"]');
                            if (_nb && typeof _nb.getClientRects === 'function' && _nb.getClientRects().length > 0) _nextVisible = true;
                        }
                    } catch (_) {}
                    if (!_nextVisible) {
                        // 第一步：点本页 .pXX03 触发滚动揭示（新页首次）
                        const _tr = _actP ? _actP.querySelector('.p1703, .p1803, .p1903, .p2003, [class*="p1703"], [class*="p1803"], [class*="p1903"], [class*="p2003"]') : null;
                        const _curKey = _tr ? String(_tr.className || '') : 'none';
                        if (State._scrollRevealKey !== _curKey) {
                            if (_tr) {
                                try { if (typeof DOMUtils !== 'undefined' && DOMUtils.simulateClick) DOMUtils.simulateClick(_tr); } catch (_) {}
                                try { _tr.click(); } catch (_) {}
                                try { if (typeof $ !== 'undefined') $(_tr).trigger('click'); } catch (_) {}
                                State._scrollRevealKey = _curKey;
                                State._scrollRevealAt = Date.now();
                                try { Logger.info('[滚动揭示] 已点击 ' + _curKey + ' 触发 box 滚动'); } catch (_) {}
                            } else {
                                State._scrollRevealKey = 'none';
                            }
                            return;
                        }
                        // 第二步：等 box 滚动动画（站点 1600ms + 余量）；超时重置重试
                        if (Date.now() - (State._scrollRevealAt || 0) < 2500) return;
                        if (Date.now() - (State._scrollRevealAt || 0) > 8000) {
                            State._scrollRevealKey = null;
                            try { Logger.warning('[滚动揭示] 8s 未显示 btn-base，重置重试'); } catch (_) {}
                        }
                        return;
                    }
                    // btn-base 已显示（滚动完成）→ 放行翻页，重置状态
                    State._scrollRevealKey = null;
                }
            } catch (_) {}

            // page-3 逐点查看互动页（P3btn 4 组三连击）：.p0301-N → .p0304-N → .p0305-N。
            // 每组独立：点 .p0301-N 后站点 1400ms 才显示并绑定 .p0304-N；点 .p0304-N 同步显示 .p0305-N；
            // 点 .p0305-N 后站点 1000ms 检查 .p0305[tag='1'] 数量 >=4 才显示 .page-3 .btn-base。
            try {
                if (GraphicAdapter.isPage3InteractPage(doc)) {
                    const _actP = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                    let _nextVisible = false;
                    try {
                        if (_actP) {
                            const _nb = _actP.querySelector('.btn-next, [class*="btn-next"]');
                            if (_nb && typeof _nb.getClientRects === 'function' && _nb.getClientRects().length > 0) _nextVisible = true;
                        }
                    } catch (_) {}
                    if (!_nextVisible) {
                        if (!State._p3State) State._p3State = { stage: 'A', a: [], b: [], c: [], t0: 0 };
                        const _st = State._p3State;
                        const _now = Date.now();
                        // 阶段 A：逐一点击 4 个 .p0301-N
                        if (_st.stage === 'A') {
                            for (let _n = 1; _n <= 4; _n++) {
                                if (_st.a.includes(_n)) continue;
                                const _el = _actP.querySelector('.p0301-' + _n);
                                if (_el) {
                                    try { if (typeof DOMUtils !== 'undefined' && DOMUtils.simulateClick) DOMUtils.simulateClick(_el); } catch (_) {}
                                    try { _el.click(); } catch (_) {}
                                    try { if (typeof $ !== 'undefined') $(_el).trigger('click'); } catch (_) {}
                                }
                                _st.a.push(_n); // 元素缺失也标记，防卡死
                            }
                            if (_st.a.length >= 4) { _st.stage = 'B'; _st.t0 = Date.now(); }
                            try { Logger.info(`[page-3互动] 阶段A 已点 ${_st.a.length}/4`); } catch (_) {}
                            return;
                        }
                        // 阶段 B：等 1400ms 动画后逐一点击可见的 .p0304-N
                        if (_st.stage === 'B') {
                            if (_now - _st.t0 < 1500) return; // 等站点 setTimeout(1400) 显示并绑定 .p0304-N
                            for (let _n = 1; _n <= 4; _n++) {
                                if (_st.b.includes(_n)) continue;
                                const _el = _actP.querySelector('.p0304-' + _n);
                                let _vis = false;
                                try { if (_el && typeof _el.getClientRects === 'function') _vis = _el.getClientRects().length > 0; } catch (_) {}
                                if (_el && _vis) {
                                    try { if (typeof DOMUtils !== 'undefined' && DOMUtils.simulateClick) DOMUtils.simulateClick(_el); } catch (_) {}
                                    try { _el.click(); } catch (_) {}
                                    try { if (typeof $ !== 'undefined') $(_el).trigger('click'); } catch (_) {}
                                }
                                _st.b.push(_n);
                            }
                            if (_st.b.length >= 4) { _st.stage = 'C'; }
                            try { Logger.info(`[page-3互动] 阶段B 已点 ${_st.b.length}/4`); } catch (_) {}
                            return;
                        }
                        // 阶段 C：逐一点击可见的 .p0305-N（点 .p0304-N 后站点同步显示 .p0305-N 并绑定）
                        if (_st.stage === 'C') {
                            for (let _n = 1; _n <= 4; _n++) {
                                if (_st.c.includes(_n)) continue;
                                const _el = _actP.querySelector('.p0305-' + _n);
                                let _vis = false;
                                try { if (_el && typeof _el.getClientRects === 'function') _vis = _el.getClientRects().length > 0; } catch (_) {}
                                if (_el && _vis) {
                                    try { if (typeof DOMUtils !== 'undefined' && DOMUtils.simulateClick) DOMUtils.simulateClick(_el); } catch (_) {}
                                    try { _el.click(); } catch (_) {}
                                    try { if (typeof $ !== 'undefined') $(_el).trigger('click'); } catch (_) {}
                                }
                                _st.c.push(_n);
                            }
                            try { Logger.info(`[page-3互动] 阶段C 已点 ${_st.c.length}/4`); } catch (_) {}
                            return; // 等站点 1000ms 后检查 tag>=4 显示 .btn-base
                        }
                        return;
                    }
                    // .btn-next 已显示（4 组互动完成）→ 放行翻页
                }
            } catch (_) {}

            // page-15 逐一点击互动页（createP15 7 组）：每组点 .p150N 或 .p150N-1 任一计一组，
            // 7 组全点后站点 1000ms 检查 clickedGroups.size>=7 显示 .page-15 .btn-base。
            // 逐一点击（每轮一组），避免同组动画锁与瞬时连点特征。
            try {
                if (GraphicAdapter.isPage15InteractPage(doc)) {
                    const _actP = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                    let _nextVisible = false;
                    try {
                        if (_actP) {
                            const _nb = _actP.querySelector('.btn-next, [class*="btn-next"]');
                            if (_nb && typeof _nb.getClientRects === 'function' && _nb.getClientRects().length > 0) _nextVisible = true;
                        }
                    } catch (_) {}
                    if (!_nextVisible) {
                        if (!State._p15Groups) State._p15Groups = [];
                        const _groups = ['p1503', 'p1504', 'p1505', 'p1506', 'p1507', 'p1508', 'p1509'];
                        for (const _g of _groups) {
                            if (State._p15Groups.includes(_g)) continue;
                            const _el = _actP.querySelector('.' + _g + ', .' + _g + '-1');
                            if (_el) {
                                try { if (typeof DOMUtils !== 'undefined' && DOMUtils.simulateClick) DOMUtils.simulateClick(_el); } catch (_) {}
                                try { _el.click(); } catch (_) {}
                                try { if (typeof $ !== 'undefined') $(_el).trigger('click'); } catch (_) {}
                                State._p15Groups.push(_g);
                                try { Logger.info(`[page-15互动] 已点 ${_g} (${State._p15Groups.length}/7)`); } catch (_) {}
                            } else {
                                State._p15Groups.push(_g); // 元素缺失也标记，防卡死
                            }
                            break; // 逐一点击：每轮推进一组
                        }
                        return;
                    }
                    // .btn-next 已显示（7 组全点完成）→ 放行翻页
                }
            } catch (_) {}

            // page-8 点击查看页：翻页元素是 <img class="element p0806 btn-next">（无 .btn-base/<a>）。
            // 站点把 .p0806 纳入 .btn-next 统一绑定（.btn-next each → click 切页+callApinext）。
            // 显式模拟点击（真实点击查看），翻页成功后页面自然切换；Tier0 兜底再触发。
            try {
                if (GraphicAdapter.isPage8ClickPage(doc)) {
                    const _actP = doc.querySelector('.page-item.page-active') || doc.querySelector('[class^="page-"].page-active, .page-active');
                    const _p0806 = _actP ? _actP.querySelector('.p0806, [class*="p0806"]') : null;
                    let _vis = false;
                    try { if (_p0806 && typeof _p0806.getClientRects === 'function') _vis = _p0806.getClientRects().length > 0; } catch (_) {}
                    if (_vis && !State._p8Clicked) {
                        try { if (typeof DOMUtils !== 'undefined' && DOMUtils.simulateClick) DOMUtils.simulateClick(_p0806); } catch (_) {}
                        try { _p0806.click(); } catch (_) {}
                        try { if (typeof $ !== 'undefined') $(_p0806).trigger('click'); } catch (_) {}
                        State._p8Clicked = true;
                        try { Logger.info('[page-8点击] 已点击 p0806 查看'); } catch (_) {}
                        return;
                    }
                    // 已点过：页面若已切换自然离开；若站点未切页，交回下方翻页逻辑（Tier0 [class*="btn-next"]）兜底
                }
            } catch (_) {}

            // 问答页
            try {
                if (GraphicAdapter.isQuizPage(doc)) {
                    if (!State.quizCompleted) {
                        let hq = false;
                        try {
                            hq = GraphicAdapter.handleQuizSelection(doc);
                        } catch (e) {}
                        if (hq === 'waiting') {
                            // 接口答案（listQuestion isCorrect）加载中：不置 quizCompleted，
                            // 不翻页，下轮重试，直到拿到真实答案一次答对
                            return;
                        }
                        State.quizCompleted = true;
                        Logger.debug('已处理问答选择');

                        const quizBtn = doc.querySelector('.btn-aq, .btn-aq-item, button[class*="aq"], a[class*="aq"]');
                        if (quizBtn) {
                            setTimeout(() => {
                                try { DOMUtils.simulateClick(quizBtn); } catch (e) {}
                                State.quizCompleted = false;
                            }, 300);
                        }
                        return;
                    }
                } else {
                    State.quizCompleted = false;
                }
            } catch (e) {
                try { Logger.debug(`问答处理异常: ${e.message}`); } catch (_) {}
            }

            // 点击下一页（四级优先级：优先页面原生 JS → Tier1 读取JS调站点函数 → Tier2 加active class → Tier3 class模糊匹配）
            try {
                // ── 风控页慢速翻页节流：带 callApinext / antiFraudIdentifyAnalysis 的图文页，
                //    每翻一页至少停留 CONFIG.riskPageTurnDelay[0]~[1] ms（随机），避免点击过快触发 701。
                //    完成页（isLastPage）不受节流影响（isLastPage 分支在翻页逻辑之前已处理）。
                if (CONFIG.riskPageMode !== false) {
                    try {
                        if (!State._riskPageSig) State._riskPageSig = '';
                        let sig = '';
                        try { const fr = GraphicJsAdapter._courseFrame(); sig = (fr && fr.src) ? String(fr.src).substring(0, 100) : ''; } catch (_) {}
                        if (State._riskPageSig !== sig) {
                            State._riskPageSig = sig;
                            // 若已由 reportStep 锁定（实际发出过 jupiterapi 进度上报）→ 保持 true，
                            // 不因 iframe script 扫描 miss 而覆盖为 false（否则慢速翻页永不生效）
                            if (!State._riskPageHit) State._riskPageHit = GraphicJsAdapter.isRiskControlledPage(doc);
                            // 首次进入风控页：先停留一个随机间隔再翻第一页（首屏同样按停留时长判定）
                            if (State._riskPageHit) {
                                const dr0 = CONFIG.riskPageTurnDelay || [10000, 15000];
                                const mi0 = (Array.isArray(dr0) ? dr0[0] : dr0) || 10000;
                                const ma0 = (Array.isArray(dr0) ? dr0[1] : mi0) || mi0;
                                State._riskNextTurnAt = Date.now() + mi0 + Math.floor(Math.random() * Math.max(1, (ma0 - mi0 + 1)));
                                State._lastRiskTurnTs = Date.now();
                                try { Logger.info('[风控页] 已进入，先停留首屏（慢速翻页模式）'); } catch (_) {}
                            } else {
                                State._riskNextTurnAt = 0;
                            }
                        }
                        if (State._riskPageHit) {
                            const now = Date.now();
                            if (!State._riskNextTurnAt) State._riskNextTurnAt = 0;
                            if (now < State._riskNextTurnAt) {
                                // 还没到翻页时间：跳过本轮翻页（主循环其余检测仍执行）
                                return;
                            }
                            const dr = CONFIG.riskPageTurnDelay || [10000, 15000];
                            const min = (Array.isArray(dr) ? dr[0] : dr) || 10000;
                            const max = (Array.isArray(dr) ? dr[1] : min) || min;
                            State._riskNextTurnAt = now + min + Math.floor(Math.random() * Math.max(1, (max - min + 1)));
                            try { Logger.info(`[风控页] 已停留 ${Math.floor((now - (State._lastRiskTurnTs || now)) / 1000)}s，开始翻页（下页间隔 ${min}-${max}ms）`); } catch (_) {}
                            State._lastRiskTurnTs = now;
                        }
                    } catch (_) {}
                }
                // ── Tier 0（NEW · 最高）：页面原生 jQuery/Global JS 翻页（GraphicJsAdapter.advancePage）──
                // 完全模拟站点 $(".btn-next").click handler 内部的行为：
                //   $(".page-" + sum).addClass("page-active").siblings().removeClass("page-active")
                // 与 Tier1 的区别：Tier1 触发 .btn-next 的 jQuery handler（受 btn_timer=1200ms 节流、
                //   若按钮被隐藏则 handler 无法触发）；Tier0 直接执行 handler 内部语句，绕过节流与按钮可见性，
                //   成功即返回。失败（非 page-N 结构 / 起始页 / 特殊页 / jQuery & DOM 均不可切）时回退 Tier1。
                try {
                    if (!State.isPageTurning) {
                        const jsAdv = GraphicJsAdapter.advancePage(doc, false);
                        if (jsAdv.ok) {
                            State.isPageTurning = true;
                            State.pageTurnTriggerTime = Date.now();
                            State.pageTurnTriggerSelector = 'Tier0-GraphicJsAdapter.' + (jsAdv.reason || 'advancePage');
                            // 翻页前记录"翻页前页面"id（activeIndex 为翻页前的 active 索引）→ 验证时 hasPageTurned
                            // 才能判定页面已切换并解锁 isPageTurning（否则存翻页后 id → hasPageTurned 恒 false →
                            // isPageTurning 卡 12.5s 超时 → 期间互动页分支被 return 拦截 → scroll 页卡死）。
                            try { State.lastActiveSectionId = GraphicAdapter.getSectionIdByIndex(doc, activeIndex); } catch (_) {}
                            Statistics.recordPageView();
                            try { Logger.info(`[JS优先·翻页·Tier0] ${jsAdv.from || '?'} → ${jsAdv.to || '?'} (${jsAdv.reason})`); } catch (_) {}
                            // 进度上报（callApinext，finish=2）：站点 .btn-next handler 触发（btn-next-triggered）
                            // 时站点已自行 callApinext 上报 statusercourse，脚本不重复（否则每次翻页接口发两次 +
                            // 脚本/站点 step 计数冲突 → 更易触发 701 风控）；非 native 翻页（btn-base/scroll/class）
                            // 由翻页验证阶段统一兜底上报一次。
                            State._turnNative = /btn-next-triggered/i.test(String(jsAdv.reason || ''));
                            State._turnReported = false;
                            this.startPageTurnVerify(doc, activeIndex);
                            return;
                        }
                    }
                } catch (_) {}

                // ── Tier1（次高）：读取课程 build JS 检测 → 调用站点 .btn-next 函数翻页 ──
                // 完全对齐 A11081.js：触发站点 .btn-next handler → _nextPage() 移动 .page-active，
                // 末页自动 finishWxCourse()。含 btn_timer=1200ms 节流对齐。
                const jsTurn = GraphicAdapter.turnPageByJs(doc);
                if (jsTurn && jsTurn.clicked) {
                    // 已调用站点翻页函数（等同站点原生翻页链路）
                    State.isPageTurning = true;
                    State._turnNative = true; // 站点翻页函数内部含 callApinext 上报，脚本不重复
                    State._turnReported = false;
                    State.pageTurnTriggerTime = Date.now();
                    State.pageTurnTriggerSelector = 'Tier1-js-fn';
                    try { State.lastActiveSectionId = GraphicAdapter.getSectionIdByIndex(doc, activeIndex); } catch (_) {}
                    Statistics.recordPageView();
                    this.startPageTurnVerify(doc, activeIndex);
                    return;
                }
                // 站点节流窗口内：本轮不动作，避免与站点待执行的翻页点击冲突
                if (jsTurn && jsTurn.reason === 'throttled') {
                    return;
                }
                // 已被 [btn-next 兜底] 点过：不重复触发、不做 Tier2（避免同 cycle 双重翻页），交给 Tier3 验证
                if (!(jsTurn && jsTurn.reason === 'already-clicked')) {
                    // ── Tier2（兜底）：给下一个 section 加 page-active class（确定性切页）──
                    // allowStart=false：起始页交由开始按钮逻辑处理，避免跳过开始
                    if (GraphicAdapter.forceAdvancePage(doc, false)) {
                        State.isPageTurning = true;
                        State.pageTurnTriggerTime = Date.now();
                        State.pageTurnTriggerSelector = 'Tier2-class';
                        State._turnNative = false; // 手动 class 切换，站点 handler 未参与 → 验证阶段脚本兜底上报
                        State._turnReported = false;
                        try { State.lastActiveSectionId = GraphicAdapter.getSectionIdByIndex(doc, activeIndex); } catch (_) {}
                        Statistics.recordPageView();
                        this.startPageTurnVerify(doc, activeIndex);
                        return;
                    }
                }

                // ── Tier3（最后）：class 模糊匹配（现有 findNextButton）──
                const nextBtn = GraphicAdapter.findNextButton(doc);
                if (nextBtn) {
                    // 若该按钮已在本次 checkPageInternal 内被 [btn-next 兜底] 点击过，
                    // 跳过重复点击（避免连点翻两页），但保留翻页校验
                    const alreadyClickedByFallback = !!nextBtn.getAttribute &&
                        nextBtn.getAttribute('data-shuake-nextclicked') === '1';

                    // 站点节流对齐（防抖）：两次真实点击间隔 ≥1400ms，避免命中站点 1200ms 节流被吞
                    if (!alreadyClickedByFallback) {
                        const nowClick = Date.now();
                        if (State.lastNextClickTime && nowClick - State.lastNextClickTime < 1400) {
                            return;
                        }
                        State.lastNextClickTime = nowClick;
                    }

                    if (!alreadyClickedByFallback) {
                        Logger.debug('点击下一页按钮');
                        // 主路径点击后同样打标记：若该按钮点击后未翻页，下一轮不再被 findNextButton 找到，
                        // 避免每轮重复点击同一个未生效按钮导致死循环（配合 findNextButton 的 isDeadNext 跳过）
                        try { nextBtn.setAttribute('data-shuake-nextclicked', '1'); } catch (_) {}
                    }

                    // 使用统一标记翻页触发：记录 page-active 标识 + 当前 URL
                    State.isPageTurning = true;
                    State.pageTurnTriggerTime = Date.now();
                    State.pageTurnTriggerSelector = nextBtn.tagName + '.' + (nextBtn.className || '').substring(0, 30);
                    State._turnNative = false; // 兜底点击，站点上报不确定 → 验证阶段脚本兜底上报一次
                    State._turnReported = false;
                    // 翻页前记录（activeIndex 为翻页前的 active 索引）→ hasPageTurned 正确判定切换
                    try { State.lastActiveSectionId = GraphicAdapter.getSectionIdByIndex(doc, activeIndex); } catch (_) {}

                    if (!alreadyClickedByFallback) {
                        try {
                            if (nextBtn.tagName === 'IMG') {
                                const parent = nextBtn.closest('a, button, div[onclick], [role="button"]');
                                DOMUtils.simulateClick(parent || nextBtn);
                            } else {
                                DOMUtils.simulateClick(nextBtn);
                            }
                        } catch (e) {}
                    }
                    Statistics.recordPageView();

                    this.startPageTurnVerify(doc, activeIndex);
                    return;
                }
            } catch (e) {
                try { Logger.debug(`下一页处理异常: ${e.message}`); } catch (_) {}
            }

            // 没有找到下一页按钮
            State.retryCount++;
            Logger.debug(`未找到下一页按钮，第 ${State.retryCount} 次重试 (页: ${activeIndex + 1}/${totalSections})`);

            // 检测是否为课程结束（有 page-end-back 按钮）
            try {
                if (State.retryCount >= 2) {
                    const endBackBtn = doc.querySelector('.page-end-back, [class*="page-end-back"]');
                    Logger.debug(`检测 page-end-back: ${!!endBackBtn}, visible=${endBackBtn ? DOMUtils.isVisible(endBackBtn) : false}`);
                    
                    if (endBackBtn && DOMUtils.isVisible(endBackBtn)) {
                        Logger.warning(`检测到 page-end-back (重试${State.retryCount}次)，课程已结束`);
                        State.graphicCompleted = true;
                        State.retryCount = 0;

                        // 【JS 优先】只调 completeCourse（→ finishWxCourse），不再自动 backToList：
                        // 用户明确「不要自动调 backToList，否则无法触发结束课程 js 逻辑」。
                        // delay=0：同步立即执行结束上报（finishWxCourse 默认需 1000ms，这里避免
                        // requestInject / 跳转打断 timer，确保结束接口先被发起）。
                        try {
                            const cmplRes = GraphicJsAdapter.completeCourse(doc, 0);
                            if (cmplRes.ok) try { Logger.info(`[JS优先·兜底结束] completeCourse → ${cmplRes.reason} (delay=${cmplRes.delay}ms pbgfn=${cmplRes.pbgfn})`); } catch (_) {}
                        } catch (_) {}
                        // ⚠️ 不再调用 GraphicJsAdapter.backToList(doc)
                        // ⚠️ 不再 DOM 模拟点击 page-end-back / back-list

                        // 【权威完成】检测到结束页：默认不直接请求完成接口（avoidDirectFinish 防风控 701）。
                        if (!CONFIG.avoidDirectFinish) {
                            try { this.completeCourseByV2(); } catch (_) {}
                        }
                        
                        setTimeout(() => {
                            try { this.requestInject(); } catch (e) {}
                        }, CONFIG.injectDelay);
                        return;
                    }
                }
            } catch (e) {
                Logger.debug(`检测结束页异常: ${e.message}`);
            }

            // 【逐一点击】页内存在多个可点元素（page-N-contentN / img 触发器等）时，
            // 每轮只点击一个尚未点击过的触发器，全部点完仍无法翻页才进入强制翻页。
            // 替代原"只点最后一个 img.element"的单一逻辑。
            try {
                const activeSectionT = _activeSection;
                if (activeSectionT && State.retryCount >= 2) {
                    // 【冷却】相邻两次触发器点击至少间隔 3s，让站点处理完上一次 reveal
                    // （grid 逐格显示依赖此间隔，过快会只响应第一格）
                    const nowT = Date.now();
                    if (State.lastTriggerClickTime && (nowT - State.lastTriggerClickTime) < CONFIG.triggerClickCooldown) {
                        return;
                    }
                    // 【grid 页状态机】grid → box → grid → box 严格依次；
                    // grid 页优先走 findNextGridAction，避免"先点完所有 grid 再点 box"的错误顺序
                    const gridAct = GraphicAdapter.findNextGridAction(doc, activeSectionT);
                    if (gridAct && gridAct.action && gridAct.action !== 'done') {
                        if (gridAct.action === 'wait') {
                            // 前置 box 未完成：等待（有上限），不点其他元素
                            State.boxWaitCount = (State.boxWaitCount || 0) + 1;
                            if (State.boxWaitCount < 12) { State.retryCount = 0; return; }
                        } else {
                            const el = gridAct.el;
                            if (el) {
                                // reclickContent：清除旧标记后重新点击，触发对应 box 显示；
                                // 同一 content 连续 reclick 上限 3 次，超限转等待（避免死循环卡在 grid 上）
                                if (gridAct.action === 'reclickContent') {
                                    const rk = el.className || el.tagName || '';
                                    if (State.lastReclickKey === rk) {
                                        State.reclickCount = (State.reclickCount || 0) + 1;
                                    } else {
                                        State.lastReclickKey = rk;
                                        State.reclickCount = 1;
                                    }
                                    if (State.reclickCount > 3) {
                                        State.boxWaitCount = (State.boxWaitCount || 0) + 1;
                                        if (State.boxWaitCount < 12) { State.retryCount = 0; return; }
                                        try { Logger.warning(`content 重试超限（${State.reclickCount} 次），等待 box 显示超时后跳过`); } catch (_) {}
                                    } else {
                                        try { el.removeAttribute('data-shuake-trigger-clicked'); } catch (_) {}
                                    }
                                }
                                try { el.setAttribute('data-shuake-trigger-clicked', '1'); } catch (_) {}
                                try { Logger.info(`grid 顺序点击 [${gridAct.action}]: <${el.tagName.toLowerCase()} class="${(el.className || '').substring(0, 50)}">`); } catch (_) {}
                                GraphicAdapter.clickStartButton(el);
                                State.lastTriggerClickTime = Date.now();
                                State.boxWaitCount = 0;
                                State.retryCount = 0;
                                return;
                            }
                        }
                    }
                    const trigger = GraphicAdapter.findNextTrigger(doc, activeSectionT);
                    if (trigger) {
                        try { trigger.setAttribute('data-shuake-trigger-clicked', '1'); } catch (_) {}
                        try { Logger.info(`逐一点击页内触发器: <${trigger.tagName.toLowerCase()} class="${(trigger.className || '').substring(0, 50)}">`); } catch (_) {}
                        GraphicAdapter.clickStartButton(trigger);
                        State.lastTriggerClickTime = Date.now();
                        State.boxWaitCount = 0;
                        State.retryCount = 0;
                        // 等待页面响应；下次 handler 循环继续点击下一个未点击的触发器
                        return;
                    }
                }
            } catch (e) {
                try { Logger.debug(`逐一点击触发器异常: ${e.message}`); } catch (_) {}
            }

            // 强制翻页兜底（仅在页内已无未点击触发器时才触发，避免跳过必须的逐一点击；
            // 阈值：纯图文长页（无 .boxbg grid 交互，无异步按钮机制）提前到 2 次重试触发，
            // 有 boxbg 的 grid 交互页保留 4 次阈值，给站点留出"点完触发器后异步显示下一页按钮"的时间）
            let forceThreshold = 4;
            try {
                const _forceAct = _activeSection;
                if (_forceAct && !_forceAct.querySelector('.boxbg')) {
                    forceThreshold = 2;
                }
            } catch (_) {}
            if (State.retryCount >= forceThreshold) {
                try {
                    // 【回退检测】强制翻页（切 class）会被站点 JS 回退到更早的页（如 18→19 被回退到 8）。
                    // 一旦累计回退 2 次，就停用强制翻页，只靠真实点击推进，避免 8↔18 死循环。
                    if (State.forceAdvanceReverts >= 2) {
                        try { Logger.warning(`检测到强制翻页多次被站点回退（${State.forceAdvanceReverts} 次），停用强制翻页，改为等待真实点击`); } catch (_) {}
                        State.retryCount = 0;
                        return;
                    }
                    const activeSectionT2 = _activeSection;
                    if (GraphicAdapter.findNextTrigger(doc, activeSectionT2)) {
                        // 还有未点击的触发器：不强制翻页，清空重试计数等下一轮继续点击
                        State.retryCount = 0;
                        return;
                    }
                    // 【boxbg 等待】grid 点完后 boxbg 逐个显示（box1→box2→box3→box4），
                    // 只要还有未显示的 box 或 box 内还有未点击元素，就不强制翻页，继续等待
                    if (GraphicAdapter.hasPendingBox(doc, activeSectionT2)) {
                        State.boxWaitCount = (State.boxWaitCount || 0) + 1;
                        if (State.boxWaitCount < 12) {
                            // 等待 box 显示（每轮约 1-2s，12 轮约 24s 上限）
                            State.retryCount = 0;
                            return;
                        }
                        try { Logger.warning(`boxbg 等待超时（${State.boxWaitCount} 轮），继续强制翻页`); } catch (_) {}
                    }
                    // 最后再查一次下一页按钮（可能因触发器点击而异步出现）
                    if (GraphicAdapter.findNextButton(doc)) {
                        State.retryCount = 0;
                        return;
                    }
                    // 记录本次强制翻页目标索引，用于回退检测
                    const curActiveIdx = (() => {
                        try {
                            const valid = Array.from(doc.querySelectorAll('.page-item')).filter(s =>
                                !s.classList.contains('page-start') && !s.classList.contains('page-end'));
                            return valid.findIndex(s => s.classList.contains('page-active'));
                        } catch (_) { return -1; }
                    })();
                    if (GraphicAdapter.forceAdvancePage(doc)) {
                        State.retryCount = 0;
                        State.isPageTurning = true;
                        State.pageTurnTriggerTime = Date.now();
                        State.pageTurnTriggerSelector = 'forceAdvancePage';
                        State.lastForceAdvanceIdx = curActiveIdx;
                        State.lastForceAdvanceTime = Date.now();
                        setTimeout(() => { GraphicAdapter.clearPageTurnLock(); }, CONFIG.pageTurnDelay + 200);
                        return;
                    }
                } catch (e) {}
            }

            if (State.retryCount >= 5) {
                Logger.debug(`页面无按钮且重试 ${State.retryCount} 次，触发重新检测`);
                State.retryCount = 0;
                setTimeout(() => {
                    try { this.requestInject(); } catch (e) {}
                }, CONFIG.injectDelay);
                return;
            }

            if (State.retryCount > CONFIG.maxRetryAttempts) {
                Logger.debug(`连续${State.retryCount}次未找到下一页按钮`);
                if (!State.graphicCompleted) {
                    State.graphicCompleted = true;
                    setTimeout(() => {
                        try { this.requestInject(); } catch (e) {}
                    }, CONFIG.injectDelay);
                }
            }
            }   // 关闭 if (!skipGraphicFlow) 图文页面处理互斥包
        }

        handleVideoComplete() {
            try {
                // 【图文互斥·防御纵深】图文课程不执行独立视频完成流程：
                // 图文 page-0 内嵌真实视频由 handleEmbeddedVideo 处理（快进→站点 timeupdate 自动切页），
                // 独立流程（handleVideoComplete）会标记完成、点 back-btn 提前退出课程。
                // 即使 registerVideoEvents 注册的 videojs ended 事件被触发，图文课程也在此拦下。
                try {
                    if (document.querySelector('.page-item, .page-start, .page-reciprocal, .page-end, .btn-next, .btn-aq, .btn-at, .btn-af, .btn-aq-n, .btn-aq-y')) return;
                } catch (_) {}
                // 【真实播放闭环】真实模式：至少真实播放 minVideoPlayTime 才能算完成。
                // 视频已真实播完但不足最低时长 → 延迟到满时长再完成（不卡死）；
                // 防止 videojs 加载初期 duration 虚高导致的"几 ms 即完成"绕过真实播放。
                if (CONFIG.realVideoPlay) {
                    const _st = State.videoPlayStartTime || 0;
                    const _elapsed = _st ? (Date.now() - _st) : 0;
                    if (_elapsed < (CONFIG.minVideoPlayTime || 5000)) {
                        const _wait = (CONFIG.minVideoPlayTime || 5000) - _elapsed;
                        try { Logger.debug(`真实播放 ${Math.round(_elapsed / 1000)}s，等待满最低时长后完成（+${Math.round(_wait)}ms）`); } catch (_) {}
                        if (!State._realPlayWaitTimer) {
                            State._realPlayWaitTimer = setTimeout(() => {
                                State._realPlayWaitTimer = null;
                                try { this.handleVideoComplete(); } catch (_) {}
                            }, _wait + 300);
                        }
                        return;
                    }
                }
                if (State.videoCompleted) return;
                State.videoCompleted = true;
                // 清理真实播放延迟完成定时器（完成时不再需要）
                if (State._realPlayWaitTimer) { clearTimeout(State._realPlayWaitTimer); State._realPlayWaitTimer = null; }
                Statistics.recordPageView();

                Logger.success('视频播放完成');
                this.sendProgress(100);
                // 【刷课上报】视频 completed 上报移到 completeVideoAndInject（真正拉到 100% 后）执行：
                // 此时已等待 minVideoPlayTime，duration 才反映真实播放时长，避免此前"用时 0s"误报。

                let iframeDoc;
                try {
                    iframeDoc = IframeUtils.getIframeDoc();
                } catch (e) {
                    iframeDoc = document;
                }

                // 若翻页中（已点击过下一页按钮），跳过再次点击
                if (State.isPageTurning) {
                    Logger.debug('handleVideoComplete：翻页中，跳过再次点击');
                    this.executeInjectWithDelay();
                    return;
                }

                // VideoJS replay 按钮（仅在已结束后用于关闭 ended UI，不再重新播放）
                try {
                    if (iframeDoc.querySelector('.video-js.vjs-ended, .vjs-play-control.vjs-ended')) {
                        const replayBtn = iframeDoc.querySelector('.vjs-play-control.vjs-ended, .vjs-big-play-button');
                        // 视频已结束后，replay 按钮不应再触发；只在没找到下一页按钮时用它过渡
                        const nextBtnFound = GraphicAdapter.findNextButton(iframeDoc);
                        if (replayBtn && !nextBtnFound) {
                            try { DOMUtils.simulateClick(replayBtn); } catch (e) {}
                            Logger.debug('点击了 replay 按钮（兜底）');
                        } else if (nextBtnFound) {
                            Logger.debug('检测到下一页按钮，跳过 replay 按钮');
                        }
                    }
                } catch (e) {}

                try {
                    const nextBtn = GraphicAdapter.findNextButton(iframeDoc);
                    if (nextBtn) {
                        // 标记翻页触发，标记后再统一入口模拟点击
                        GraphicAdapter.markPageTurnTriggered('handleVideoComplete:next');
                        try { DOMUtils.simulateClick(nextBtn); } catch (e) {}
                        Logger.debug('点击视频页面继续按钮');
                    } else {
                        const endBtns = iframeDoc.querySelectorAll('.btn-base, .btn-next, button[class*="next"], [class*="next" i], [class*="btn-primary"]');
                        let clickedEnd = false;
                        for (const btn of endBtns) {
                            try {
                                if (btn.offsetParent !== null && !btn.disabled) {
                                    const text = (btn.textContent || '').trim();
                                    if (/下|完成|结束|提交|继续/i.test(text)) {
                                        GraphicAdapter.markPageTurnTriggered('handleVideoComplete:end');
                                        DOMUtils.simulateClick(btn);
                                        Logger.debug(`点击了结束按钮: ${text}`);
                                        clickedEnd = true;
                                        break;
                                    }
                                }
                            } catch (_) {}
                        }
                        if (!clickedEnd) {
                            // 找不到任何结束按钮，释放锁，让下一次轮询再尝试
                            GraphicAdapter.clearPageTurnLock();
                        }
                    }
                } catch (e) {
                    GraphicAdapter.clearPageTurnLock();
                }

                // 只在没找到下一页按钮 / 没点击的情况下走 back 兜底，否则不重复触发
                // （之前的实现总是延时 500ms 点击 back，会和新页面交互打架）
                setTimeout(() => {
                    try {
                        if (State.isPageTurning && !GraphicAdapter.hasPageTurned(document)) {
                            // 翻页未真正完成，仍可能在等待站点响应，暂不点击 back
                            return;
                        }
                        const iconBack = document.querySelector('.icon-back, #play .icon-back');
                        if (iconBack) {
                            try { DOMUtils.simulateClick(iconBack); } catch (e) {}
                            Logger.debug('点击 .icon-back 返回按钮');
                            return;
                        }
                        const backBtn = document.querySelector('.back-btn, .back-btn-img');
                        if (backBtn) {
                            try { DOMUtils.simulateClick(backBtn); } catch (e) {}
                            Logger.debug('点击 back-btn 返回按钮');
                        }
                    } catch (e) {}
                }, 500);

                this.executeInjectWithDelay();
            } catch (e) {
                try { Logger.debug(`handleVideoComplete 异常: ${e.message}`); } catch (_) {}
            }
        }

        executeInjectWithDelay() {
            try {
                if (State.injectExecuted) {
                    Logger.debug('inject 已执行，跳过');
                    return;
                }

                const elapsedTime = State.videoPlayStartTime ? Date.now() - State.videoPlayStartTime : 0;
                const remainingDelay = Math.max(0, (CONFIG.minVideoPlayTime || 5000) - elapsedTime);

                if (remainingDelay > 0) {
                    Logger.debug(`视频播放时间 ${elapsedTime}ms，还需等待 ${remainingDelay}ms`);
                    setTimeout(() => {
                        try { this.completeVideoAndInject(); } catch (e) {}
                    }, remainingDelay);
                } else {
                    this.completeVideoAndInject();
                }
            } catch (e) {
                try { Logger.debug(`executeInjectWithDelay 异常: ${e.message}`); } catch (_) {}
            }
        }

        completeVideoAndInject() {
            try {
                if (State.injectExecuted) return;

                let videoInfo;
                try {
                    videoInfo = VideoAdapter.detectInIframe() || { type: VideoAdapter.detect(document), doc: document, win: window };
                } catch (e) {
                    videoInfo = { type: null, doc: null, win: null };
                }
                let iframeDoc;
                let iframeWin;
                try {
                    iframeDoc = IframeUtils.getIframeDoc() || document;
                    iframeWin = IframeUtils.getIframeWindow() || window;
                } catch (e) {
                    iframeDoc = document;
                    iframeWin = window;
                }

                if (videoInfo && videoInfo.type && videoInfo.doc) {
                    try {
                        const player = VideoAdapter.getPlayer(videoInfo.type, videoInfo.doc, videoInfo.win || iframeWin);
                        if (player) {
                            VideoAdapter.complete(videoInfo.type, player);
                            Logger.debug(`视频进度已拉到100%`);
                        }
                    } catch (e) {}
                }

                // 【刷课上报】视频真正拉到 100% 后上报 completed（登录云端才生效，防重）。
                // duration 自视频开始播放（videoPlayStartTime 触发 ensureStarted）计时，此时已 ≥minVideoPlayTime，
                // 计时真实；若上报失败，下次 report 重试（completed 防重仅在成功后置位）。
                try {
                    if (State.videoCompleted) StudyReporter.report('completed');
                } catch (_) {}

                this.executeInjectWithRetry();
            } catch (e) {
                try { Logger.debug(`completeVideoAndInject 异常: ${e.message}`); } catch (_) {}
            }
        }

        executeInjectWithRetry() {
            try {
                if (State.injectExecuted) {
                    Logger.debug(`inject 已执行，跳过`);
                    return;
                }

                if (this.injectRetryCount >= this.maxInjectRetry) {
                    Logger.error(`inject 重试 ${this.maxInjectRetry} 次均失败，3秒后刷新页面...`);
                    setTimeout(() => {
                        try { location.reload(); } catch (_) {}
                    }, 3000);
                    return;
                }

                try { this.pullVideoProgress(); } catch (e) {}

                State.injectExecuted = true;

                Logger.debug('执行 inject...');
                this.requestInject();

                const handleResult = (e) => {
                    try {
                        if (e?.data?.type === 'injectResult') {
                            window.removeEventListener('message', handleResult);
                            if (!e.data.success) {
                                this.injectRetryCount++;
                                State.injectExecuted = false;
                                if (this.injectRetryCount < this.maxInjectRetry) {
                                    Logger.warning(`inject 失败，${CONFIG.injectDelay * (this.injectRetryCount + 1)}ms 后重试 (${this.injectRetryCount}/${this.maxInjectRetry})`);
                                    setTimeout(() => {
                                        try { this.executeInjectWithRetry(); } catch (err) {}
                                    }, CONFIG.injectDelay * (this.injectRetryCount + 1));
                                } else {
                                    Logger.error(`inject 重试 ${this.maxInjectRetry} 次均失败，3秒后刷新页面...`);
                                    setTimeout(() => {
                                        try { location.reload(); } catch (_) {}
                                    }, 3000);
                                }
                            }
                        }
                    } catch (err) {}
                };
                window.addEventListener('message', handleResult);
            } catch (e) {
                try { Logger.debug(`executeInjectWithRetry 异常: ${e.message}`); } catch (_) {}
            }
        }

        pullVideoProgress() {
            try {
                let videoInfo;
                try {
                    videoInfo = VideoAdapter.detectInIframe() || { type: VideoAdapter.detect(document), doc: document, win: window };
                } catch (e) {
                    videoInfo = { type: null };
                }
                let iframeDoc, iframeWin;
                try {
                    iframeDoc = IframeUtils.getIframeDoc() || document;
                    iframeWin = IframeUtils.getIframeWindow() || window;
                } catch (e) {
                    iframeDoc = document;
                    iframeWin = window;
                }

                if (videoInfo && videoInfo.type) {
                    try {
                        const player = VideoAdapter.getPlayer(videoInfo.type, videoInfo.doc || iframeDoc, videoInfo.win || iframeWin);
                        if (player) {
                            VideoAdapter.complete(videoInfo.type, player);
                            Logger.debug('视频进度已拉到100%');
                        }
                    } catch (e) {}
                }
            } catch (err) {
                try { Logger.debug(`拉进度失败: ${err.message}`); } catch (_) {}
            }
        }

        doInject() {
            try {
                if (State.injectExecuted) return;
                State.injectExecuted = true;
                Logger.debug('执行 inject...');
                this.requestInject();
            } catch (e) {
                try { Logger.debug(`doInject 异常: ${e.message}`); } catch (_) {}
            }
        }

        // 【权威完成判定】是否真的全部完成：仅以服务端 showProgress.do 的 finished===1 为唯一依据。
        // 背景：此前"未拉取到未完成课程"会被当成"全部完成"直接自动暂停，
        // 实际服务端可能仍是未完成（如 120/135 课时 + 考试未过），导致刷课被误停。
        // 因此这里直接实时请求权威接口、不走缓存；拿不到权威结果一律视为"未确认完成"→ 不暂停、继续尝试。
        async confirmProjectDone() {
            try {
                let info = null;
                try {
                    if (typeof ProjectInfo !== 'undefined') {
                        ProjectInfo.parseURL();
                        info = ProjectInfo;
                    }
                } catch (_) {}
                const token = (info && typeof info.getAuthHeaders === 'function') ? info.getAuthHeaders() : null;
                if (!token) {
                    try { Logger.debug('confirmProjectDone: 无 token，视为未确认完成'); } catch (_) {}
                    return false;
                }
                const url = 'https://weiban.mycourse.cn/pharos/project/showProgress.do';
                const resp = await AjaxHooker.apiFetch(url, {
                    method: 'POST',
                    credentials: 'include',
                    headers: Object.assign({}, AjaxHooker.getSiteHeaders(), {
                        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                        'x-token': token,
                        'Accept': 'application/json'
                    }),
                    body: `userProjectId=${(info && info.userProjectId) || ''}&tenantCode=${(info && info.tenantCode) || ''}&userId=${(info && info.userId) || ''}&chooseType=3`
                });
                if (!resp || !resp.ok) {
                    try { Logger.debug(`confirmProjectDone: HTTP ${resp ? resp.status : '无响应'}`); } catch (_) {}
                    return false;
                }
                const result = await resp.json();
                if (result && result.code === '0' && result.data) {
                    const done = Number(result.data.finished) === 1;
                    try {
                        if (typeof ProjectInfo !== 'undefined') {
                            ProjectInfo.data = result.data;
                            DataCache.save('project', result.data);
                        }
                    } catch (_) {}
                    try {
                        Logger.info(`[权威判定] showProgress.finished=${result.data.finished} → ${done ? '全部完成' : '未完成(课程 ' + result.data.requiredFinishedNum + '/' + result.data.requiredNum + '，考试 ' + result.data.examFinishedNum + '/' + result.data.examNum + ')'}`);
                    } catch (_) {}
                    return done;
                }
                return false;
            } catch (e) {
                try { Logger.debug(`confirmProjectDone 异常: ${e.message}`); } catch (_) {}
                return false;
            }
        }

        // 【权威完成·最高优先级】直接调 sdk.js 定义的完成接口 v2/{userCourseId}.do（jsonp GET）。
        // 与站点 finishWxCourse()->finish() 完全同款：参数 userCourseId + tenantCode + uniqueNo(页面有 uuid 时)。
        // 用途：普通图文模式到达末页(.page-end)时兜底调用，确保即使站点 .btn-next handler 未触发
        // finishWxCourse()（如经 forceAdvancePage 强制翻页到达末页），服务端也能记录课程完成。
        // 与站点自身的 v2 调用幂等兼容（重复提交返回成功，无弹窗/评价跳转等副作用）。
        async completeCourseByV2() {
            // sdk.js 对齐：4 条 finish URL 分支 + jsonp / uniqueNo / csCom 评价 / csCapt 腾讯验证码，
            // 不再只覆盖 weiban.mycourse.cn v2/${userCourseId}.do 单一分支。
            // 这里本质上调用 GraphicJsAdapter._finishSDK()，因为它已经完整实现了 sdk.js finish()。
            try {
                if (State._v2CompleteCalled) return false;
                State._v2CompleteCalled = true;
                // 调用前确保 SDK 环境初始化（backToList / finishWxCourse / wx 覆盖 / 东财 resize）
                try { GraphicJsAdapter._installSDKEnv(); } catch (_) {}

                const sdkPromise = GraphicJsAdapter._finishSDK();
                const r = (sdkPromise && typeof sdkPromise.then === 'function') ? (await sdkPromise) : null;
                const ok = !!(r && r.ok);
                try {
                    Logger.info(`[权威完成] sdk.js 对齐 4 分支 URL ${ok ? '✅' : '提交失败'}（${r && r.url || 'unknown'}，code=${r && r.code != null ? r.code : 'N/A'}）`);
                } catch (_) {}
                // 【刷课上报】课程完成：上报 completed（登录云端才生效，防重）
                // 到达末页即视为完成：即使 sdk finish 因环境缺失（mcwk 直接 / 跨域 iframe）返回
                // ok=false，也照常上报，避免"图文翻完但没有上报记录"。sdk 提交结果仅作日志区分。
                try { StudyReporter.report('completed'); } catch (_) {}
                return ok;
            } catch (e) {
                try { Logger.debug(`completeCourseByV2 异常: ${e.message}`); } catch (_) {}
                return false;
            }
        }

        // 翻页验证：触发翻页（Tier1 调函数 / Tier2 切 class / Tier3 模糊点击）后等待 page-active 切换，
        // 判定成功或卡页；卡 2 次才强制翻页。三级翻页共用此验证，避免重复代码与同 cycle 双重动作。
        startPageTurnVerify(doc, activeIndex) {
            setTimeout(() => {
                try {
                    // 【暂停/停止】暂停或停止后跳过翻页校验，避免暂停后仍被强制翻页/连点
                    if (State.isPaused || !State.isRunning) return;
                    // 真正的"页面切换成功"判定：page-active 已切到下一项
                    if (GraphicAdapter.hasPageTurned(doc)) {
                        State.stuckCount = 0;
                        GraphicAdapter.clearPageTurnLock();
                        try { Logger.debug(`翻页成功: ${State.pageTurnTriggerSelector}`); } catch (_) {}
                        // 进度上报（callApinext，finish=2）：仅"非 native 翻页"且"本次未上报过"才脚本兜底上报一次；
                        // 站点 .btn-next handler 触发（btn-next-triggered/Tier1）时站点已自行 callApinext 上报，
                        // 脚本不重复，否则每次翻页 statusercourse 接口发两次 + step 计数冲突 → 更易触发 701。
                        try {
                            if (!State._turnNative && !State._turnReported) {
                                GraphicJsAdapter.reportStep(doc);
                                State._turnReported = true;
                            }
                        } catch (_) {}
                    } else {
                        const newIndex = GraphicAdapter.getActiveSectionIndex(doc);
                        if (newIndex === activeIndex) {
                            State.stuckCount = (State.stuckCount || 0) + 1;
                            Logger.debug(`点击未生效，已卡 ${State.stuckCount} 次 (页 ${activeIndex + 1})`);
                            // 卡 2 次才强制翻页；且强制前确认页内已无【未点击过的触发器】——
                            // 只有还"该点没点"的元素时才等待继续点；否则直接跳过本页到下个 section
                            if (State.stuckCount >= 2) {
                                try {
                                    let stillHasClick = false;
                                    try {
                                        const actS = doc.querySelector('.page-item.page-active');
                                        if (GraphicAdapter.findNextTrigger(doc, actS)) stillHasClick = true;
                                    } catch (_) {}
                                    if (!stillHasClick && GraphicAdapter.forceAdvancePage(doc)) {
                                        State.stuckCount = 0;
                                    }
                                } catch (e) {}
                            }
                        } else {
                            State.stuckCount = 0;
                        }
                        GraphicAdapter.clearPageTurnLock();
                    }
                } catch (e) {
                    GraphicAdapter.clearPageTurnLock();
                }
            }, CONFIG.pageTurnDelay + 200);
        }

        pause() {
            try {
                State.isPaused = true;
                // 【同步面板】快捷键暂停后面板状态/按钮同步
                try { if (window.shuakePanelInstance && typeof window.shuakePanelInstance.updateStatus === 'function') window.shuakePanelInstance.updateStatus('已暂停', 'paused'); } catch (_) {}
                try { gmWriteJSON('shuake_run_state', { isRunning: State.isRunning, isPaused: true }); } catch (_) {}
                Logger.info('已暂停');
            } catch (e) {}
        }

        // 【自动暂停】所有课程完成后自动暂停脚本，避免每轮主循环空转刷屏"所有课程已完成"
        // 仅在首次检测到完成时暂停一次（_autoPausedOnComplete 防重复）；
        // 用户 resume() 后会清除标记，允许下次重新完成时再次自动暂停
        autoPauseOnComplete() {
            try {
                if (State._autoPausedOnComplete) return false;
                State._autoPausedOnComplete = true;
                State.isPaused = true;
                try { Logger.success('🎉 所有课程已完成，已自动暂停脚本（点击面板"继续"可重新开始）'); } catch (_) {}
                try { showFloatToast('所有课程已完成，已自动暂停'); } catch (_) {}
                try {
                    if (window.shuakePanelInstance && typeof window.shuakePanelInstance.updateStatus === 'function') {
                        window.shuakePanelInstance.updateStatus('已暂停（全部完成）', 'paused');
                    }
                } catch (_) {}
                return true;
            } catch (e) {
                return false;
            }
        }

        resume() {
            try {
                State.isPaused = false;
                // 用户手动继续后清除自动暂停标记，允许之后再次"全部完成"时自动暂停
                State._autoPausedOnComplete = false;
                // 【同步面板】快捷键继续后面板状态/按钮同步
                try { if (window.shuakePanelInstance && typeof window.shuakePanelInstance.updateStatus === 'function') window.shuakePanelInstance.updateStatus('运行中', ''); } catch (_) {}
                try { gmWriteJSON('shuake_run_state', { isRunning: State.isRunning, isPaused: false }); } catch (_) {}
                Logger.info('已继续');
            } catch (e) {}
        }

        stop() {
            try {
                if (this.loopTimer) {
                    clearInterval(this.loopTimer);
                    this.loopTimer = null;
                }
                if (this.statsTimer) {
                    clearInterval(this.statsTimer);
                    this.statsTimer = null;
                }
                if (this.injectRetryTimer) {
                    clearTimeout(this.injectRetryTimer);
                    this.injectRetryTimer = null;
                }
                if (this.mutationObserver) {
                    try { this.mutationObserver.disconnect(); } catch (_) {}
                    this.mutationObserver = null;
                }
                if (this._pageWatchStop) {
                    try { this._pageWatchStop(); } catch (_) {}
                    this._pageWatchStop = null;
                }
                if (this._messageHandler) {
                    try { window.removeEventListener('message', this._messageHandler); } catch (_) {}
                    this._messageHandler = null;
                }
                if (this._keyboardHandler) {
                    try { document.removeEventListener('keydown', this._keyboardHandler); } catch (_) {}
                    this._keyboardHandler = null;
                }
                try { DOMWatcher.disposeAll(); } catch (_) {}
                try { AjaxHooker.uninstall(); } catch (_) {}
                State.isRunning = false;
                State.isExamPage = false;
                State.aiProcessing = false;
                this._running = false;
                // 【同步面板】快捷键停止后按钮状态同步为"开始刷课"
                try { if (window.shuakePanelInstance && window.shuakePanelInstance._state) window.shuakePanelInstance._state.running = false; } catch (_) {}
                // 【持久化】停止状态写入 GM，防止页面更新/刷新丢失
                try { gmWriteJSON('shuake_run_state', { isRunning: false, isPaused: true }); } catch (_) {}
                Logger.warning('刷课已停止');
            } catch (e) {
                try { Logger.debug(`stop 异常: ${e.message}`); } catch (_) {}
            }
        }
    }

    // ========== 启动 ==========
    // 预安装 ajax-hook 数据窃听（不依赖 Vue/TDesign；ajax-hook 通过 @require 在 document-start 已就绪）
    // weiban SPA 详情页 / mcwk 学习页在 Vue/TDesign CDN 加载期间就会发起 API 请求，
    // 提前劫持可确保 listCategory/listPrePlan/showProgress/getCourse 的成功响应不丢失、尽早写入缓存。
    try {
        if (Libs.hasAjaxHook) {
            if (!AjaxHooker._hooked) {
                if (AjaxHooker.install()) {
                    AjaxHooker.installFetch();
                    registerDataEavesdrop();
                    Logger.info('预安装 ajax-hook 数据窃听（XHR+fetch，库加载期间已就绪）');
                }
            } else {
                AjaxHooker.installFetch();
                registerDataEavesdrop();
            }
        }
    } catch (_) {}

    // 等待库加载后再初始化控制器
    waitForLibraries(() => {
        console.log('%c[麦课助手] ✅ 初始化完成，开始主流程', 'color: #2196F3; font-weight: bold; font-size: 14px');
        console.log('[麦课助手] ✅ ShuaKePanel 已加载');
        
        // 【调试标记】立即设置最基础的 __shuake 对象，确保能看到回调执行了
        try {
            window.__shuake = window.__shuake || {};
            window.__shuake._callbackExecuted = true;
            window.__shuake._timestamp = new Date().toISOString();
            console.log('[麦课助手] ✅ __shuake 标记已设置');
        } catch (e) {
            console.error('[麦课助手] ❌ 无法设置 __shuake 标记:', e);
        }
        
        // 预加载题库与云端健康检查（不阻塞主流程）
        try {
            DataBridge.registerListener();
            // 持久化当前页身份参数（跨页复用 userProjectId/userId/tenantCode 等）
            try { StoredIdentity.save(); } catch (_) {}
            QuestionBank.loadAll();
            Logger.info(`本地题库: ${QuestionBank.count()} 条`);
            // 题库为空或面板数据缓存缺失时，尝试从兄弟子域拉取（列表页/课程页 host 不同导致 localStorage 隔离）
            const needSync = QuestionBank.count() === 0
                || DataCache.load('category') == null
                || DataCache.load('exam') == null
                || DataCache.load('project') == null;
            if (needSync) {
                DataBridge.syncFromSiblings(5000).then((applied) => {
                    try {
                        Logger.info(`跨子域数据桥: ${applied ? '已同步兄弟子域数据' : '无可用数据或桥接被拦截'}`);
                        if (applied) {
                            try { window.shuakePanelInstance?.refreshCoursePanel(); } catch (_) {}
                            Logger.info(`本地题库（跨子域后）: ${QuestionBank.count()} 条`);
                        }
                    } catch (_) {}
                }).catch(() => {});
            }
        } catch (e) {
            try { Logger.debug(`题库预加载失败: ${e.message}`); } catch (_) {}
        }
        if (CloudBank.isEnabled()) {
            CloudBank.healthCheck().then((ok) => {
                try { Logger.info(ok ? '云端题库已连接' : `云端题库未连接: ${CloudBank.getStatus().lastError || ''}`); } catch (_) {}
            });
        } else {
            try { Logger.info('云端题库未启用（如需启用请在面板题库管理中打开）'); } catch (_) {}
        }

        // 微伴游客账号：未登录时自动用微伴身份注册登录并持久化（服务端未实现时静默降级为游客上报）
        try {
            if (typeof WeibanAutoAuth !== 'undefined' && typeof WeibanAutoAuth.autoRegisterLogin === 'function') {
                WeibanAutoAuth.autoRegisterLogin().then((r) => {
                    try {
                        if (r && r.ok && window.shuakePanelInstance && typeof window.shuakePanelInstance.refreshAll === 'function') {
                            window.shuakePanelInstance.refreshAll();
                        }
                    } catch (_) {}
                });
            }
        } catch (_) {}


        let controller;
        try {
            console.log('[麦课助手] 🚀 开始创建 ShuaKeController...');
            controller = new ShuaKeController();
            console.log('[麦课助手] ✅ ShuaKeController 创建成功');
        } catch (e) {
            console.error('[麦课助手] ❌ ShuaKeController 创建失败:', e);
            console.error('[麦课助手] 错误堆栈:', e.stack);
            // 即使失败也要暴露基础功能
        }

        window.__shuake = {
            controller,
            State,
            CONFIG,
            CanvasCourse,
            ConfigManager,
            Logger,
            Network,
            DOMUtils,
            DOMWatcher,
            PageType,
            CourseInfo,
            ProjectInfo,
            CategoryInfo,
            StudyAssistant,
            ExamManager,
            AIAnswer,
            QuestionBank,
            CloudBank,
            Statistics,
            ControlPanel,
            openSettings: (tab) => {
                try {
                    if (controller && controller.panel && typeof controller.panel.refreshAIConfigPanel === 'function') {
                        controller.panel.refreshAIConfigPanel();
                        controller.panel.refreshBankPanel();
                        controller.panel.refreshCoursePanel();
                    }
                } catch (e) {}
            },
            stop: () => controller.stop(),
            resume: () => { State.isPaused = false; },
            pause: () => { State.isPaused = true; }
        };

        // 【极速模式登录跳转鉴权】登录后自动续跑：
        // 上一轮因无 token 跳转到 weiban 登录，登录成功后（weiban 域 localStorage['user'] 有 token）
        // 脚本在此页面重新加载，检测到 pending 标记且已有登录态 → 清除标记并自动继续极速刷课。
        try {
            const pendingLogin = (StudyAssistant && StudyAssistant.PendingTurboLogin)
                ? StudyAssistant.PendingTurboLogin.get() : null;
            const hostname = (window.location.hostname || '').toLowerCase();
            if (pendingLogin && hostname.includes('weiban')) {
                const hasToken = !!(readStoredToken());
                if (hasToken) {
                    try { StudyAssistant.PendingTurboLogin.clear(); } catch (_) {}
                    try { Logger.info(`[极速模式] 登录完成，自动续跑极速刷课（原因: ${pendingLogin.reason || ''}）`); } catch (_) {}
                    // 等面板/控制器就绪后自动继续（延后避免与启动初始化竞争）
                    setTimeout(() => {
                        try {
                            if (controller && typeof controller.autoAdvanceByAPI === 'function') {
                                controller.autoAdvanceByAPI();
                            }
                        } catch (_) {}
                    }, 1500);
                } else {
                    // 已标记但尚未登录：再给一次引导
                    try { Logger.warning('[极速模式] 检测到待登录标记，但登录态仍缺失，请先在页面完成登录'); } catch (_) {}
                }
            }
        } catch (_) {}
    });

})();