// ==UserScript==
// @name         英语听力填空助手（超星学习通）
// @namespace    chaoxing-fill-blank
// @version      4.5.2
// @author       fysh
// @description  超星学习通英语听力填空题助手：章节扫描音频建立任务队列，逐条「转写→匹配标红→填空」；4.5.1 增强多电脑兼容，修复部分环境音频下载 HTTP 403，并支持 403 后刷新临时音频地址重试。
// @icon         https://www.google.com/s2/favicons?domain=chaoxing.com
// @match        *://*.chaoxing.com/*
// @match        *://*.edu.cn/*
// @match        *://*.nbdlib.cn/*
// @match        *://*.hnsyu.net/*
// @match        *://*.gdhkmooc.com/*
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_addStyle
// @grant        GM_registerMenuCommand
// @grant        GM_xmlhttpRequest
// @grant        unsafeWindow
// @connect      *
// @run-at       document-end
// ==/UserScript==

(function () {
  'use strict';

  /* =========================================================================
   * 一、基础配置与工具
   * =======================================================================*/

  const CONFIG_KEY = 'cx_fill_blank_config';
  const MARKER = '@@BLANK@@'; // 片段中代表一个空位的占位标记
  const CONTAINER_SELECTOR = '.TiMu, .questionLi, .mark_table';
  const WORD_RE = /[A-Za-z0-9]+(?:['\u2019\-][A-Za-z0-9]+)*/g;

  const defaultConfig = {
    originalText: '',   // 手动粘贴/转写的英文原文
    originalTextChapter: '', // 原文所属章节；跨章节时自动失效，避免把上一章原文带到新章节
    autoFill: false,    // 是否自动填空（默认关闭：只有显式勾选「自动填写」或手动点按钮才会填写）
    answerInterval: 1,  // 每个空之间的填写间隔(秒)
    audioUrl: '',       // 听力音频地址（留空则自动识别页面上的音频）
    audioAuto: false,   // 进入页面后是否自动转写音频
    autoNext: false,    // 所有音频处理完成后是否自动进入下一章
    whisperModel: 'Xenova/whisper-small.en', // 语音识别模型（只保留最准的 small.en）
    modelHost: 'https://hf-mirror.com', // 模型下载源（国内镜像更稳；官方为 https://huggingface.co）
  };

  // 只保留最准的模型，避免「base 不准→换 small 重试→重复下载」的流程
  const WHISPER_MODEL = 'Xenova/whisper-small.en';

  const IS_TOP = (() => {
    try { return window.self === window.top; } catch (e) { return false; }
  })();

  // 页面真实 window：油猴沙箱里 window.UE 取不到，必须用 unsafeWindow
  const PAGE = (() => {
    try { return (typeof unsafeWindow !== 'undefined' && unsafeWindow) ? unsafeWindow : window; } catch (e) { return window; }
  })();

  // 安全获取页面上的 UEditor 库
  function getUE() {
    try { if (PAGE && PAGE.UE) return PAGE.UE; } catch (e) { /* ignore */ }
    try { if (window.UE) return window.UE; } catch (e) { /* ignore */ }
    return null;
  }

  // 等待 UEditor 就绪（最多 timeoutMs 毫秒）
  async function ensureUE(timeoutMs) {
    if (getUE()) return true;
    const deadline = Date.now() + (timeoutMs || 0);
    while (Date.now() < deadline) {
      await sleep(0.2);
      if (getUE()) return true;
    }
    return !!getUE();
  }

  function getConfig() {
    try {
      const saved = GM_getValue(CONFIG_KEY, {});
      return Object.assign({}, defaultConfig, saved || {});
    } catch (e) {
      return Object.assign({}, defaultConfig);
    }
  }

  function saveConfig(patch) {
    const cfg = Object.assign(getConfig(), patch);
    try { GM_setValue(CONFIG_KEY, cfg); } catch (e) { /* ignore */ }
    return cfg;
  }

  const sleep = (sec) => new Promise((r) => setTimeout(r, Math.max(0, sec) * 1000));

  function withTimeout(promise, ms, message) {
    return new Promise((resolve, reject) => {
      const t = setTimeout(() => reject(new Error(message || '操作超时')), ms);
      Promise.resolve(promise).then(
        (v) => { clearTimeout(t); resolve(v); },
        (e) => { clearTimeout(t); reject(e); }
      );
    });
  }

  /* =========================================================================
   * 二、日志（子 iframe 的日志会转发给顶层面板）
   * =======================================================================*/

  const LOG_STYLE = {
    info: 'color:#409eff;font-weight:bold',
    success: 'color:#67c23a;font-weight:bold',
    error: 'color:#f56c6c;font-weight:bold',
  };

  function log(msg, level = 'info') {
    try { console.log('%c[填空助手] ' + msg, LOG_STYLE[level] || LOG_STYLE.info); } catch (e) { /* ignore */ }
    if (IS_TOP) {
      appendLog(msg, level);
    } else {
      try { window.top.postMessage({ __cxfill: true, type: 'log', msg, level }, '*'); } catch (e) { /* ignore */ }
    }
  }

  /* =========================================================================
   * 三、核心匹配算法
   *
   * 四层匹配：
   *  ① 文本规范化：统一大小写、撇号、用于匹配的“归一化词形”
   *  ② 题目结构：把片段切成「词 + 空」，相邻上下文即为锚点
   *  ③ 容错对齐：带相似度加权的序列对齐（容忍 Whisper 的拼写/漏词误差）
   *  ④ 消歧/置信度：按对齐结果逐空取词，并给出匹配置信度
   * =======================================================================*/

  /** 匹配用的词形归一化（不改动展示原文） */
  function normalizeWord(w) {
    return String(w).toLowerCase().replace(/[\u2018\u2019\u02bc]/g, "'");
  }

  /** 编辑距离 */
  function levenshteinDistance(a, b) {
    const n = a.length;
    const m = b.length;
    if (!n) return m;
    if (!m) return n;
    let prev = new Array(m + 1);
    let cur = new Array(m + 1);
    for (let j = 0; j <= m; j++) prev[j] = j;
    for (let i = 1; i <= n; i++) {
      cur[0] = i;
      for (let j = 1; j <= m; j++) {
        const cost = a[i - 1] === b[j - 1] ? 0 : 1;
        cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
      }
      const t = prev; prev = cur; cur = t;
    }
    return prev[m];
  }

  function stringSimilarity(a, b) {
    const maxLen = Math.max(a.length, b.length);
    if (!maxLen) return 1;
    return 1 - levenshteinDistance(a, b) / maxLen;
  }

  /** 两个词的匹配得分：精确 3；近似 1~2；否则 0 */
  function tokenScore(a, b) {
    if (a === b) return 3;
    if (a.length >= 4 && b.length >= 4 && Math.abs(a.length - b.length) <= 2) {
      const sim = stringSimilarity(a, b);
      if (sim >= 0.82) return 2;
      if (sim >= 0.7) return 1;
    }
    return 0;
  }

  /** 把文本切成英文单词数组（保留原样，含撇号/连字符） */
  function tokenize(text) {
    const out = [];
    const re = new RegExp(WORD_RE.source, 'g');
    let m;
    while ((m = re.exec(text)) !== null) out.push(m[0]);
    return out;
  }

  /** 把带占位标记的片段切成 token 序列：空白处为 {blank:true} */
  function tokenizeFragment(text) {
    const parts = String(text).split(MARKER);
    const tokens = [];
    parts.forEach((part, i) => {
      if (i > 0) tokens.push({ blank: true });
      tokenize(part).forEach((w) => tokens.push({ raw: w, norm: normalizeWord(w) }));
    });
    return tokens;
  }

  /**
   * 容错序列对齐：返回 { map, matched }
   *  map[i] = 片段第 i 个非空词匹配到的原文下标（-1 表示未匹配）
   *  matched = 成功匹配（含近似匹配）的次数，用于置信度
   */
  function lcsMatch(fTokens, oTokens) {
    const n = fTokens.length;
    const m = oTokens.length;
    if (!n || !m) return { map: new Int32Array(n).fill(-1), matched: 0 };

    const fNorm = fTokens.map((t) => t.norm);
    const oNorm = oTokens.map((t) => normalizeWord(t));

    const dp = [];
    for (let i = 0; i <= n; i++) dp.push(new Int32Array(m + 1));
    for (let i = 1; i <= n; i++) {
      const row = dp[i];
      const prev = dp[i - 1];
      const fn = fNorm[i - 1];
      for (let j = 1; j <= m; j++) {
        const s = tokenScore(fn, oNorm[j - 1]);
        const best = Math.max(prev[j], row[j - 1], s > 0 ? prev[j - 1] + s : 0);
        row[j] = best;
      }
    }

    const map = new Int32Array(n).fill(-1);
    let matched = 0;
    let i = n;
    let j = m;
    while (i > 0 && j > 0) {
      // 若当前原文词对最优分数没有贡献，先跳过它：让锚点尽量靠前，
      // 这样「缺失词」会留在空位区间里，而不是被遗漏在第一个锚点之前。
      if (dp[i][j - 1] === dp[i][j]) { j--; continue; }
      const s = tokenScore(fNorm[i - 1], oNorm[j - 1]);
      if (s > 0 && dp[i][j] === dp[i - 1][j - 1] + s) {
        map[i - 1] = j - 1;
        matched++;
        i--;
        j--;
      } else if (dp[i - 1][j] >= dp[i][j - 1]) {
        i--;
      } else {
        j--;
      }
    }
    return { map: map, matched: matched };
  }

  /**
   * 清洗原文：去掉答案键里的序号（形如 "1." "2." … 的递增编号）。
   * 这些序号是「答案列表的编号」，不是原文内容，留着会被当成词参与匹配，
   * 从而把空的分配挤错位（例如 "mountain 6 climbing"）。
   * 只删「非字母数字且非点号」前缀 + 1~3 位数字 + 点号 + 空格，且数值必须正好接上 1,2,3… 的递增序列，
   * 避免误删 "0.69"、"150." 之类的真实数字。
   */
  function cleanOriginalText(text) {
    let expected = 1;
    return String(text == null ? '' : text).replace(/(^|[^\w.])(\d{1,3})\.(?=\s)/g, function (m, pre, num) {
      const n = parseInt(num, 10);
      // 允许跳过 1~2 个编号（原文偶尔漏抄），避免序列一旦断开就再也不清洗
      if (n >= expected && n <= expected + 2) { expected = n + 1; return pre; }
      return m;
    });
  }

  /**
   * 求解：把「题干片段」和「原文」做 diff，**原文里对不上的词 = 答案**。
   * 关键模型：**一个「序号」= 一个答案组 = 一个输入框**，组内可以是一段短语（多个词）。
   * 序号后面跟几个下划线不影响分组（下划线只表示“这里有空”，不用来数词数）。
   *
   * 做法：按题干顺序走，遇到序号就开始一个新组；遇到空位就标记“当前组有空”；
   *       遇到已对齐的锚点词，就把「上一个锚点 ~ 这个锚点」之间对不上的原文词全部塞进当前组。
   * 片段里的纯数字（序号 "1." "2." …）不参与对齐，避免吃掉原文里的数字答案。
   *
   * @returns {{groups: Array<{no:number,words:string[],positions:number[]}>, matched:number, wordCount:number}}
   */
  function matchAnswers(fragmentText, originalText) {
    const ft = tokenizeFragment(fragmentText);
    const ot = tokenize(originalText);
    const isSerial = (raw) => /^\d+$/.test(raw);

    const fWords = ft.filter((t) => !t.blank && !isSerial(t.raw));
    const aligned = lcsMatch(fWords, ot);

    const used = new Uint8Array(ot.length);
    for (let i = 0; i < aligned.map.length; i++) {
      const oi = aligned.map[i];
      if (oi >= 0) used[oi] = 1;
    }

    // 注意：groups 不能丢掉“没有识别出答案”的空。
    // 否则例如 15~20 整段漏转写后，21 会被顺位写入第 15 个输入框。
    const groups = [];      // { no, idxs, blanks, blankFPos, reliable, reason }
    let current = null;
    let openedInGap = [];
    let lastO = -1;
    let fi = 0;             // 已走过的题干非空、非序号词数量
    let seqNo = 0;

    function newGroup(no) {
      const g = {
        no: (no == null ? ++seqNo : no),
        idxs: [],
        blanks: 0,
        blankFPos: [],
        reliable: true,
        reason: '',
      };
      groups.push(g);
      current = g;
      return g;
    }

    // 处理 [lastO+1, nextOi-1]：把原文中额外出现的词分配给本区间里的空。
    function flush(nextOi) {
      if (openedInGap.length) {
        const missing = [];
        for (let i = lastO + 1; i <= nextOi - 1; i++) if (!used[i]) missing.push(i);
        if (missing.length) {
          if (openedInGap.length === 1) {
            for (let k = 0; k < missing.length; k++) openedInGap[0].idxs.push(missing[k]);
          } else {
            const totalB = openedInGap.reduce((sum, g) => sum + (g.blanks || 0), 0) || openedInGap.length;
            let pos = 0;
            for (let gi = 0; gi < openedInGap.length; gi++) {
              const g = openedInGap[gi];
              const share = Math.round(missing.length * ((g.blanks || 1) / totalB));
              const part = missing.slice(pos, Math.min(pos + share, missing.length));
              for (let k = 0; k < part.length; k++) g.idxs.push(part[k]);
              pos += part.length;
            }
            for (let k = pos; k < missing.length; k++) openedInGap[openedInGap.length - 1].idxs.push(missing[k]);
          }
        }
      }
      openedInGap = [];
    }

    for (const tok of ft) {
      if (tok.blank) {
        if (!current) newGroup(null);
        current.blanks++;
        // 记录这个空位位于第几个“已知题干词”之后，用于后面的局部断裂判断。
        current.blankFPos.push(fi);
        if (openedInGap.indexOf(current) < 0) openedInGap.push(current);
        continue;
      }
      if (isSerial(tok.raw)) { newGroup(parseInt(tok.raw, 10)); continue; }
      const oi = aligned.map[fi++];
      if (oi >= 0) { flush(oi); lastO = oi; }
    }
    flush(ot.length);

    // ---------------------------------------------------------------------
    // 局部断裂检测
    // 正常填空：题干相邻锚点之间，原文通常会“多出”答案词，因此 oGap >= fGap。
    // Whisper 整段漏转写：题干两个锚点之间还有很多正常已知词，但原文里它们几乎消失，
    // 会出现 fGap 很大、oGap 很小。此时该区间里的空全部标记为不可靠，禁止写入。
    // ---------------------------------------------------------------------
    function prevMatchedIndex(pos) {
      for (let i = Math.min(pos - 1, aligned.map.length - 1); i >= 0; i--) {
        if (aligned.map[i] >= 0) return i;
      }
      return -1;
    }

    function nextMatchedIndex(pos) {
      for (let i = Math.max(0, pos); i < aligned.map.length; i++) {
        if (aligned.map[i] >= 0) return i;
      }
      return -1;
    }

    groups.forEach(function (g) {
      if (!g.blanks) return;
      const bpos = g.blankFPos.length ? g.blankFPos[0] : 0;
      const pf = prevMatchedIndex(bpos);
      const nf = nextMatchedIndex(bpos);
      if (pf < 0 || nf < 0 || nf <= pf) return;

      const po = aligned.map[pf];
      const no = aligned.map[nf];
      if (po < 0 || no < 0 || no <= po) return;

      const fGap = nf - pf - 1;   // 两个锚点之间题干仍有多少个正常已知词
      const oGap = no - po - 1;   // 两个锚点之间转写原文有多少个词

      // 保守阈值：至少丢了 5 个正常题干词，并且原文只保留不到约 30%。
      // 这样不会把普通 1~2 个 Whisper 拼写/漏词误判成“整段缺失”。
      const collapsed = fGap >= 6 && (fGap - oGap) >= 5 && oGap <= Math.max(1, Math.floor(fGap * 0.30));
      if (collapsed) {
        g.reliable = false;
        g.reason = '疑似转写断层：题干锚点间有 ' + fGap + ' 个已知词，但转写仅剩 ' + oGap + ' 个';
      }
    });

    // 关键：所有真正含空位的组都要保留，即使 words=[]。
    // 这样第 21 空永远仍对应第 21 个输入框，不会因为 15~20 缺失而前移。
    const out = [];
    for (let gi = 0; gi < groups.length; gi++) {
      const g = groups[gi];
      if (!g.blanks) continue;
      out.push({
        no: g.no,
        words: g.idxs.map((i) => ot[i]),
        positions: g.idxs.slice(),
        reliable: g.reliable !== false,
        reason: g.reason || '',
      });
    }

    return {
      groups: out,
      matched: aligned.matched,
      wordCount: fWords.length,
      blankCount: ft.filter((t) => t.blank).length,
      originalWordCount: ot.length,
    };
  }

  /* =========================================================================
   * 四、页面识别与片段提取
   * =======================================================================*/

  /** 找出题目容器（章节测验 / 作业 / 考试），并剔除包含其它容器的外层，保留最内层 */
  function findContainers(root) {
    let all = [];
    try { all = Array.from(root.querySelectorAll(CONTAINER_SELECTOR)); } catch (e) { return []; }
    return all.filter((el) => !all.some((other) => other !== el && el.contains(other)));
  }

  /** 去重（按元素引用） */
  function uniqEls(arr) {
    const seen = new Set();
    return arr.filter((el) => {
      if (seen.has(el)) return false;
      seen.add(el);
      return true;
    });
  }

  /** 通用输入框查找（兜底用） */
  function findEditors(root) {
    const textareas = Array.from(root.querySelectorAll('textarea'));
    if (textareas.length) return textareas;
    return Array.from(root.querySelectorAll('.eidtDiv, [contenteditable="true"], input[type="text"]'));
  }

  /**
   * 找出填空题真正用于输入答案的控件（按文档顺序），即每个空一个：
   * 超星标准结构为 .blankItemDiv 内的 UEditor 源 textarea（name="answerEditor..."）
   */
  function findBlankEditors(container) {
    // 1) 超星标准填空题：每个空一个隐藏 textarea（UEditor 源）
    const ta = uniqEls(Array.from(container.querySelectorAll('.blankItemDiv textarea, textarea[name^="answerEditor"]')));
    if (ta.length) return ta;

    // 2) 备选：可见的可编辑区域
    const ce = uniqEls(Array.from(container.querySelectorAll('.blankItemDiv .eidtDiv, .blankItemInp [contenteditable="true"], .InpDIV')));
    if (ce.length) return ce;

    // 3) 兜底
    return findEditors(container);
  }

  /** 找到题干元素（章节/作业/考试三种结构） */
  function findStemElement(container) {
    return container.querySelector('.Zy_TItle .fontLabel')
      || container.querySelector('.Zy_TItle .newZy_TItle')
      || container.querySelector('.Zy_TItle')
      || container.querySelector('.mark_name')
      || container.querySelector('.fontLabel')
      || container;
  }

  /** 判断是否填空题 */
  function isFillBlank(container) {
    // 1) 题型编号为 2（填空题）
    try {
      const inputs = container.querySelectorAll('input[name^="answertype"], input[name^="type"]');
      for (const inp of inputs) {
        if (String(inp.value) === '2') return true;
      }
      if (container.getAttribute && container.getAttribute('data') === '2' && findBlankEditors(container).length) return true;
    } catch (e) { /* ignore */ }

    // 2) 题干里出现“填空题”
    const text = container.innerText || container.textContent || '';
    if (/填空题/.test(text)) return true;

    // 3) 兜底：出现 2 个及以上输入框
    return findBlankEditors(container).length >= 2;
  }

  /**
   * 从题干中提取「带空位标记的片段文本」。
   * 只取题干（.Zy_TItle 等），忽略下方独立的答题区，避免重复计数。
   * 空的表示形式：连续下划线，或题干里的内联输入框。
   */
  function extractFragment(container, editorCount) {
    const stem = findStemElement(container);
    const clone = stem.cloneNode(true);

    // 把题干里的内联输入框替换为内联占位（\u0001），稍后与下划线一起当作空位
    Array.from(clone.querySelectorAll('textarea, input[type="text"], .eidtDiv, [contenteditable="true"]')).forEach((el) => {
      if (el.parentNode) el.parentNode.replaceChild(document.createTextNode(' \u0001 '), el);
    });

    // 临时挂到页面外，利用 innerText 保留元素之间的空格/换行
    clone.style.cssText = 'position:fixed;left:-99999px;top:0;width:800px;opacity:0;pointer-events:none;';
    const host = document.body || document.documentElement;
    host.appendChild(clone);
    let text = clone.innerText || clone.textContent || '';
    host.removeChild(clone);

    text = text.replace(/[\r\n\t]+/g, ' ').replace(/\s{2,}/g, ' ');

    // 收集所有「空位片段」：连续下划线 + 内联输入框占位
    const spans = [];
    const runRe = /[＿_]{2,}/g;
    let m;
    while ((m = runRe.exec(text)) !== null) spans.push({ start: m.index, end: m.index + m[0].length, inline: false });
    let p = -1;
    while ((p = text.indexOf('\u0001', p + 1)) !== -1) spans.push({ start: p, end: p + 1, inline: true });
    spans.sort((a, b) => a.start - b.start);

    if (!spans.length) return { text: text.replace(/\u0001/g, ' ').trim(), blankCount: 0 };

    // 以「输入框数量」为准：片段多了就把最靠近的相邻片段合并（处理被空格拆开的同一个空），
    // 片段不多于输入框则保持独立（处理「一个编号对应多个空」）。
    let markers = spans.slice();
    const target = editorCount || markers.length;
    while (markers.length > target) {
      let bi = -1;
      let bg = Infinity;
      for (let i = 0; i < markers.length - 1; i++) {
        const gap = markers[i + 1].start - markers[i].end;
        if (gap < bg) { bg = gap; bi = i; }
      }
      if (bi < 0) break;
      markers[bi] = { start: markers[bi].start, end: markers[bi + 1].end, inline: markers[bi].inline && markers[bi + 1].inline };
      markers.splice(bi + 1, 1);
    }

    let out = '';
    let last = 0;
    for (const mk of markers) {
      out += text.slice(last, mk.start) + ' ' + MARKER + ' ';
      last = mk.end;
    }
    out += text.slice(last);

    return { text: out.replace(/\u0001/g, ' ').replace(/\s{2,}/g, ' ').trim(), blankCount: markers.length };
  }

  /* =========================================================================
   * 五、填写
   * =======================================================================*/

  function fireEvent(el, type, isInput) {
    try {
      if (isInput && typeof InputEvent === 'function') {
        el.dispatchEvent(new InputEvent(type, { bubbles: true }));
      } else {
        el.dispatchEvent(new Event(type, { bubbles: true }));
      }
    } catch (e) { /* 跨域/事件构造失败时忽略 */ }
  }

  function setBlankValue(el, value, win) {
    try {
      const tag = (el.tagName || '').toLowerCase();
      const UE = getUE();

      if (tag === 'textarea') {
        const name = el.getAttribute('name') || el.id;
        // 超星填空题使用 UEditor：必须通过页面 window 上的 UE 实例写入
        if (UE && name && typeof UE.getEditor === 'function') {
          const editor = UE.getEditor(name);
          if (editor) {
            const write = () => { try { editor.setContent(value); } catch (e) { el.value = value; } };
            if (typeof editor.ready === 'function') editor.ready(write); // 已就绪会立即执行
            write(); // 立即尝试一次
            el.value = value; // 同步隐藏源 textarea
            fireEvent(el, 'input');
            fireEvent(el, 'change');
            return true;
          }
        }
        el.value = value;
        fireEvent(el, 'input');
        fireEvent(el, 'change');
        return true;
      }

      if (el.isContentEditable || (el.className && String(el.className).indexOf('eidtDiv') !== -1)) {
        try { el.focus(); } catch (e) { /* ignore */ }
        el.textContent = value;
        fireEvent(el, 'input', true);
        fireEvent(el, 'change');
        return true;
      }

      el.value = value;
      fireEvent(el, 'input');
      fireEvent(el, 'change');
      return true;
    } catch (e) {
      return false;
    }
  }

  /* =========================================================================
   * 五·五、音频转写（浏览器内置 Whisper，无需 API key）
   *
   * 思路：
   *  1) 用 GM_xmlhttpRequest 下载音频（绕过跨域）；
   *  2) 用 Web Audio 解码并重采样为 16kHz 单声道 Float32；
   *  3) 动态加载 transformers.js，用 Whisper 英文模型转写为文本；
   *  4) 转写结果写入「原文」框，再走原来的对齐填空流程。
   * =======================================================================*/

  const TRANSFORMERS_URL = 'https://cdn.jsdelivr.net/npm/@xenova/transformers@2.17.2/dist/transformers.min.js';

  /* -------------------------------------------------------------------------
   * 音频下载（4.5.1）
   *
   * 某些学习通/CDN 音频会校验 Cookie、Referer 或临时签名。原版直接用
   * GM_xmlhttpRequest 再请求一次，在另一台电脑上可能出现 HTTP 403。
   * 现在采用：
   *   ① 页面 fetch（优先复用当前页面登录态/Cookie/浏览器 Referer）
   *   ② GM_xmlhttpRequest（跨域兜底，并尽量带当前音频所在页面 Referer）
   *   ③ 上层若收到 401/403，会重新扫描当前章节拿最新 URL 后再试一次
   * -----------------------------------------------------------------------*/

  const _audioMeta = new Map(); // url -> { referer }，扫描音频时记录其所在页面

  function rememberAudioMeta(url, referer) {
    if (!url) return;
    try {
      const r = String(referer || '').trim();
      _audioMeta.set(String(url), { referer: r || location.href });
    } catch (e) { /* ignore */ }
  }

  function audioReferer(url) {
    try {
      const m = _audioMeta.get(String(url));
      if (m && m.referer) return m.referer;
    } catch (e) { /* ignore */ }
    try { return location.href; } catch (e) { return ''; }
  }

  function shortSafeUrl(url) {
    try {
      const u = new URL(String(url), location.href);
      return u.origin + u.pathname; // 日志不打印 query，避免把临时签名/token 暴露出来
    } catch (e) {
      return String(url || '').split('?')[0].split('#')[0];
    }
  }

  function httpDownloadError(prefix, status, url, finalUrl) {
    const shown = shortSafeUrl(finalUrl || url);
    const err = new Error(prefix + ' HTTP ' + status + (shown ? '；' + shown : ''));
    err.status = Number(status) || 0;
    err.url = url || '';
    err.finalUrl = finalUrl || '';
    return err;
  }

  function isAuthDownloadError(err) {
    const s = Number(err && err.status);
    return s === 401 || s === 403;
  }

  /** 方式一：使用页面自己的 fetch，优先复用页面登录态 */
  async function getBinaryViaPageFetch(url, timeoutMs) {
    const timeout = timeoutMs || 120000;
    const pageFetch = PAGE && typeof PAGE.fetch === 'function' ? PAGE.fetch.bind(PAGE) : null;
    if (!pageFetch) throw new Error('页面 fetch 不可用');

    const AC = (PAGE && PAGE.AbortController) || (typeof AbortController !== 'undefined' ? AbortController : null);
    const controller = AC ? new AC() : null;
    const timer = controller ? setTimeout(function () { try { controller.abort(); } catch (e) { /* ignore */ } }, timeout) : null;
    try {
      const res = await pageFetch(url, {
        method: 'GET',
        credentials: 'include',
        cache: 'no-store',
        redirect: 'follow',
        signal: controller ? controller.signal : undefined,
      });
      if (!res || !res.ok) throw httpDownloadError('页面请求失败', res ? res.status : 0, url, res && res.url);
      const buf = await res.arrayBuffer();
      if (!buf || !buf.byteLength) throw new Error('页面请求返回空音频');
      return buf;
    } finally {
      if (timer) clearTimeout(timer);
    }
  }

  /** 方式二：GM_xmlhttpRequest 跨域兜底 */
  function getBinaryViaGM(url, timeoutMs) {
    const timeout = timeoutMs || 120000;
    const referer = audioReferer(url);
    return new Promise((resolve, reject) => {
      try {
        const headers = {
          'Accept': 'audio/*,application/octet-stream;q=0.9,*/*;q=0.8',
          'Cache-Control': 'no-cache',
          'Pragma': 'no-cache',
          'Range': 'bytes=0-', // 尽量模拟浏览器媒体请求，部分音频 CDN 对 Range 更兼容
        };
        // Tampermonkey/Violentmonkey 若允许设置 Referer，则使用音频所在页面；
        // 若浏览器扩展层忽略该受限请求头，也不会影响请求本身。
        if (referer) headers['Referer'] = referer;

        GM_xmlhttpRequest({
          method: 'GET',
          url: url,
          responseType: 'arraybuffer',
          timeout: timeout,
          anonymous: false,
          headers: headers,
          onload: (res) => {
            if (res.status >= 200 && res.status < 300 && res.response && res.response.byteLength) {
              resolve(res.response);
            } else {
              reject(httpDownloadError('油猴请求失败', res.status, url, res.finalUrl));
            }
          },
          onerror: (res) => {
            const err = new Error('油猴请求网络错误；' + shortSafeUrl((res && res.finalUrl) || url));
            err.status = Number(res && res.status) || 0;
            reject(err);
          },
          ontimeout: () => reject(new Error('音频下载超时；' + shortSafeUrl(url))),
        });
      } catch (e) { reject(e); }
    });
  }

  /** 页面登录态优先；失败后自动切 GM 请求。两个方式都失败时保留更有意义的 HTTP 状态 */
  async function getBinary(url, timeoutMs) {
    let pageErr = null;
    try {
      log('尝试使用页面登录态下载音频…');
      const buf = await getBinaryViaPageFetch(url, timeoutMs);
      log('页面登录态下载成功', 'success');
      return buf;
    } catch (e) {
      pageErr = e;
      log('页面下载未成功：' + ((e && e.message) || e) + '，改用油猴请求…', 'info');
    }

    try {
      const buf = await getBinaryViaGM(url, timeoutMs);
      log('油猴请求下载成功', 'success');
      return buf;
    } catch (gmErr) {
      // 若 GM 明确返回了 HTTP 状态，以 GM 状态为主；否则保留页面 fetch 的 401/403。
      if (gmErr && gmErr.status) throw gmErr;
      if (pageErr && pageErr.status) throw pageErr;
      throw gmErr || pageErr || new Error('音频下载失败');
    }
  }

  /** 把音频解码为 16kHz 单声道 Float32Array */
  async function decodeAudioTo16k(arrayBuffer) {
    const AC = (PAGE && PAGE.AudioContext) || (PAGE && PAGE.webkitAudioContext) || window.AudioContext || window.webkitAudioContext;
    const OAC = (PAGE && PAGE.OfflineAudioContext) || window.OfflineAudioContext || window.webkitOfflineAudioContext;
    if (!AC || !OAC) throw new Error('当前浏览器不支持 Web Audio');

    const ctx = new AC();
    let decoded;
    try {
      decoded = await new Promise((res, rej) => {
        const p = ctx.decodeAudioData(arrayBuffer.slice(0), res, rej);
        if (p && typeof p.then === 'function') p.then(res, rej);
      });
    } finally {
      try { ctx.close(); } catch (e) { /* ignore */ }
    }

    const targetRate = 16000;
    const length = Math.max(1, Math.ceil(decoded.duration * targetRate));
    const offline = new OAC(1, length, targetRate);
    const src = offline.createBufferSource();
    src.buffer = decoded;
    src.connect(offline.destination);
    src.start(0);
    const rendered = await offline.startRendering();
    return rendered.getChannelData(0);
  }

  /** 方式一：注入 type=module 脚本，把 transformers.js 导出挂到页面 window 上 */
  function importViaScript() {
    return new Promise((resolve, reject) => {
      try {
        const key = '__cxTransformers_' + Math.random().toString(36).slice(2);
        const doc = (PAGE && PAGE.document) || document;
        const s = doc.createElement('script');
        s.type = 'module';
        s.textContent = 'import * as M from ' + JSON.stringify(TRANSFORMERS_URL) + ';\n' +
          'window[' + JSON.stringify(key) + '] = M;';
        doc.documentElement.appendChild(s);
        const start = Date.now();
        const timer = setInterval(() => {
          let m;
          try { m = PAGE[key]; } catch (e) { m = undefined; }
          if (m) { clearInterval(timer); try { s.remove(); } catch (e) { /* ignore */ } resolve(m); }
          else if (Date.now() - start > 60000) { clearInterval(timer); reject(new Error('transformers.js 加载超时')); }
        }, 150);
      } catch (e) { reject(e); }
    });
  }

  /** 方式二：通过 new Function 动态 import（避免在脚本正文里出现 import 语法） */
  async function importViaFunction() {
    const importer = new Function('u', 'return import(u)');
    const ns = await importer(TRANSFORMERS_URL);
    return (ns && ns.pipeline) ? ns : (ns && ns.default) ? ns.default : ns;
  }

  /** 加载 transformers.js（优先注入模块脚本，其次动态 import） */
  async function loadTransformers() {
    if (loadTransformers._mod) return loadTransformers._mod;

    let mod = null;
    try {
      mod = await importViaScript();
    } catch (e) {
      try { console.warn('[填空助手] 注入模块脚本加载失败，尝试动态 import：', e && e.message); } catch (err) { /* ignore */ }
    }
    if (!mod) {
      try { mod = await importViaFunction(); } catch (e) { /* ignore */ }
    }
    if (!mod || !mod.pipeline) throw new Error('无法加载 transformers.js（可能被页面 CSP 拦截）');

    loadTransformers._mod = mod;
    return mod;
  }

  // ---------- 主线程兜底方案（worker 不可用时才用）----------
  let _transcriber = null;
  let _transcriberModel = '';

  async function createTranscriber(model, host, onProgress) {
    const mod = await loadTransformers();
    const env = mod.env;
    try { env.allowLocalModels = false; } catch (e) { /* ignore */ }
    try { env.useBrowserCache = true; } catch (e) { /* ignore */ }
    try { env.backends.onnx.wasm.numThreads = 1; } catch (e) { /* ignore */ }
    try { env.backends.onnx.wasm.proxy = false; } catch (e) { /* ignore */ }
    try { env.remoteHost = host; } catch (e) { /* ignore */ }
    try { env.remotePathTemplate = '{model}/resolve/{revision}/'; } catch (e) { /* ignore */ }
    return await mod.pipeline('automatic-speech-recognition', model, {
      quantized: true,
      progress_callback: onProgress,
    });
  }

  function modelHosts() {
    const primary = (getConfig().modelHost || 'https://hf-mirror.com').replace(/\/+$/, '');
    const backup = primary.indexOf('hf-mirror.com') !== -1 ? 'https://huggingface.co' : 'https://hf-mirror.com';
    return [primary, backup];
  }

  async function getTranscriberMain(model, onProgress) {
    if (_transcriber && _transcriberModel === model) return _transcriber;
    let lastErr = null;
    for (const host of modelHosts()) {
      try {
        _transcriber = await createTranscriber(model, host, onProgress);
        _transcriberModel = model;
        return _transcriber;
      } catch (e) {
        lastErr = e;
        log('主线程加载失败（源=' + host + '）：' + ((e && e.message) || e), 'error');
      }
    }
    throw lastErr || new Error('模型加载失败');
  }

  // ---------- 优先方案：在独立 Web Worker 里跑 Whisper，避免页面卡死 ----------
  const TRANSFORMERS_ESM = 'https://cdn.jsdelivr.net/npm/@xenova/transformers@2.17.2/dist/transformers.min.js';
  let _worker = null;

  function workerCode() {
    return [
      "import { pipeline, env } from " + JSON.stringify(TRANSFORMERS_ESM) + ";",
      "env.allowLocalModels = false;",
      "env.useBrowserCache = true;",
      "try { env.backends.onnx.wasm.numThreads = 1; } catch (e) {}",
      "let transcriber = null; let curModel = '';",
      "self.onmessage = async function (e) {",
      "  var d = e.data || {};",
      "  if (d.type !== 'transcribe') return;",
      "  try {",
      "    if (d.host) { try { env.remoteHost = d.host; env.remotePathTemplate = '{model}/resolve/{revision}/'; } catch (e2) {} }",
      "    if (!transcriber || curModel !== d.model) {",
      "      transcriber = await pipeline('automatic-speech-recognition', d.model, { quantized: true, progress_callback: function (p) { self.postMessage({ type: 'progress', p: p && { status: p.status, file: p.file, progress: p.progress } }); } });",
      "      curModel = d.model;",
      "    }",
      "    var res = await transcriber(d.audio, { chunk_length_s: 30, stride_length_s: 5, return_timestamps: false });",
      "    self.postMessage({ type: 'result', text: (res && res.text) || '' });",
      "  } catch (err) { self.postMessage({ type: 'error', message: String((err && err.message) || err) }); }",
      "};",
    ].join('\n');
  }

  function ensureWorker() {
    if (_worker) return _worker;
    const BlobC = (PAGE && PAGE.Blob) || Blob;
    const URLC = (PAGE && PAGE.URL) || URL;
    const WorkerC = (PAGE && PAGE.Worker) || Worker;
    const blob = new BlobC([workerCode()], { type: 'text/javascript' });
    const url = URLC.createObjectURL(blob);
    _worker = new WorkerC(url, { type: 'module' });
    return _worker;
  }

  function killWorker() {
    if (_worker) { try { _worker.terminate(); } catch (e) { /* ignore */ } _worker = null; }
  }

  function transcribeWithWorker(f32, model, host, onProgress) {
    return new Promise((resolve, reject) => {
      let w;
      try { w = ensureWorker(); } catch (e) { reject(e); return; }
      const onMsg = (ev) => {
        const d = ev.data || {};
        if (d.type === 'progress') { if (onProgress) onProgress(d.p); }
        else if (d.type === 'result') { cleanup(); resolve(d.text); }
        else if (d.type === 'error') { cleanup(); killWorker(); reject(new Error(d.message)); }
      };
      const onErr = () => { cleanup(); killWorker(); reject(new Error('Worker 加载失败（可能被页面 CSP 拦截）')); };
      function cleanup() {
        try { w.removeEventListener('message', onMsg); } catch (e) { /* ignore */ }
        try { w.removeEventListener('error', onErr); } catch (e) { /* ignore */ }
      }
      w.addEventListener('message', onMsg);
      w.addEventListener('error', onErr);
      try { w.postMessage({ type: 'transcribe', model, host, audio: f32 }); }
      catch (e) { cleanup(); reject(e); }
    });
  }

  const VIDEO_URL_RE = /\.(mp4|m4v|mov|avi|mkv|flv|webm|m3u8|ts)(\?|#|$)/i;

  /** blob:/data:/about:/javascript:、视频格式地址不参与转写 */
  function isNonAudioUrl(u) {
    return !u || /^blob:/i.test(u) || /^data:/i.test(u) || /^about:/i.test(u) || /^javascript:/i.test(u) || VIDEO_URL_RE.test(u);
  }

  /**
   * 从单个 document 里按「文档顺序」收集 <audio> 地址。
   * 排除 <video>、视频格式地址、与视频同源的地址，以及「页面地址」。
   * 注意：<audio src=""> 的空 src 会被浏览器解析成当前文档 URL（如 .../knowledge/cards），
   * 必须用原始属性判断是否真的有 src，否则会把页面地址误当成音频。
   */
  function collectAudioFromDoc(doc, out, seen) {
    if (!doc) return;

    let docBase = '';
    try { docBase = String(doc.location ? doc.location.href : '').split('#')[0]; } catch (e) { docBase = ''; }
    const isPageUrl = (u) => !!docBase && String(u).split('#')[0] === docBase;

    // 取媒体元素真实地址：优先 currentSrc；否则用「非空」的 src 属性
    const mediaUrl = (el) => {
      try {
        if (el.currentSrc) return el.currentSrc;
        const raw = el.getAttribute && el.getAttribute('src');
        if (raw && raw.trim()) return el.src || raw;
      } catch (e) { /* ignore */ }
      return '';
    };
    const sourceUrl = (so) => {
      try {
        const raw = so.getAttribute && so.getAttribute('src');
        if (raw && raw.trim()) return so.src || raw;
      } catch (e) { /* ignore */ }
      return '';
    };

    const videoSrcs = [];
    try {
      Array.from(doc.querySelectorAll('video')).forEach((v) => {
        const s = mediaUrl(v);
        if (s) videoSrcs.push(s);
        Array.from(v.querySelectorAll('source')).forEach((so) => {
          const u = sourceUrl(so);
          if (u) videoSrcs.push(u);
        });
      });
    } catch (e) { /* ignore */ }

    let audios = [];
    try { audios = Array.from(doc.querySelectorAll('audio')); } catch (e) { return; }

    audios.forEach((a) => {
      const cands = [];
      const own = mediaUrl(a);
      if (own) cands.push(own);
      try {
        Array.from(a.querySelectorAll('source')).forEach((so) => {
          const u = sourceUrl(so);
          if (u) cands.push(u);
        });
      } catch (e) { /* ignore */ }

      cands.forEach((u) => {
        if (isNonAudioUrl(u)) return;
        if (isPageUrl(u)) return; // src="" 会被解析成页面地址，排除
        if (videoSrcs.indexOf(u) !== -1) return; // 与视频同源，视为视频音轨
        if (seen.has(u)) return;
        seen.add(u);
        rememberAudioMeta(u, docBase || location.href);
        out.push(u);
      });
    });
  }

  /**
   * 确定性收集整章音频：从顶层窗口按「本文档 → 子 frame(按顺序)」深度优先遍历，
   * 保证音频顺序稳定，避免多 frame 异步上报导致「下拉框序号与真实位置错位」。
   * 跨域 frame 读不到 document，交由 broadcast 上报兜底。
   */
  function collectChapterAudio() {
    const out = [];
    const seen = new Set();
    const seenWins = new Set();
    (function walk(win) {
      if (!win || seenWins.has(win)) return;
      seenWins.add(win);
      let doc = null;
      try { doc = win.document; } catch (e) { doc = null; }
      if (doc) collectAudioFromDoc(doc, out, seen);
      let n = 0;
      try { n = win.frames.length; } catch (e) { return; }
      for (let i = 0; i < n; i++) {
        let w = null;
        try { w = win.frames[i]; } catch (e) { continue; }
        walk(w);
      }
    })(window.top || window);
    return out;
  }

  /** 识别当前 frame 里的音频地址（供跨域 frame 通过消息上报） */
  function detectAudioUrls() {
    const urls = [];
    collectAudioFromDoc(document, urls, new Set());
    return urls;
  }

  /** 识别页面上的音频地址（取第一个） */
  function detectAudioUrl() {
    const urls = detectAudioUrls();
    if (urls.length > 1) {
      log('当前页面检测到 ' + urls.length + ' 个音频，将使用第 1 个；如需其它请手动填写音频URL', 'error');
    }
    return urls[0] || '';
  }

  /** 转写进度日志（限流） */
  function makeProgressLogger() {
    return (p) => {
      try {
        if (p && p.status === 'progress' && p.file && p.progress != null) {
          const pct = Math.round(p.progress);
          if (pct % 20 === 0) log('模型 ' + p.file + ' ' + pct + '%');
        }
      } catch (e) { /* ignore */ }
    };
  }

  // 音频解码缓存：同一 URL 只下载/解码一次，避免重复下载
  const _audioCache = new Map();
  const AUDIO_CACHE_MAX = 3;

  function cacheAudio(url, pcm) {
    try {
      if (_audioCache.has(url)) _audioCache.delete(url);
      _audioCache.set(url, pcm);
      while (_audioCache.size > AUDIO_CACHE_MAX) {
        const first = _audioCache.keys().next().value;
        _audioCache.delete(first);
      }
    } catch (e) { /* ignore */ }
  }

  /** 完整流程：下载（带缓存） → 403 时刷新 URL 一次 → 解码 → 转写 */
  async function transcribeAudio(url, refreshUrlFn) {
    const model = WHISPER_MODEL;
    const onProgress = makeProgressLogger();
    let activeUrl = url;

    let f32 = _audioCache.get(activeUrl);
    if (f32) {
      log('使用已缓存的音频（约 ' + (f32.length / 16000).toFixed(1) + ' 秒），跳过下载…');
    } else {
      log('开始下载音频…');
      let buf;
      try {
        buf = await getBinary(activeUrl);
      } catch (e) {
        if (!isAuthDownloadError(e) || typeof refreshUrlFn !== 'function') throw e;
        log('音频服务器返回 HTTP ' + e.status + '，准备刷新地址后重试…', 'error');
        const fresh = await refreshUrlFn(activeUrl);
        if (!fresh) throw e;
        activeUrl = fresh;
        buf = await getBinary(activeUrl); // 只自动重试一次，避免死循环
      }
      log('音频已下载（' + Math.round(buf.byteLength / 1024) + ' KB），正在解码…');
      f32 = await decodeAudioTo16k(buf);
      cacheAudio(activeUrl, f32);
    }
    log('音频就绪（约 ' + (f32.length / 16000).toFixed(1) + ' 秒），正在加载语音模型（首次需下载，请耐心等待）…');

    // 优先：在独立 Worker 里推理，避免阻塞页面主线程
    for (const host of modelHosts()) {
      try {
        log('在后台 Worker 中加载模型（源=' + host + '）…');
        const text = await transcribeWithWorker(f32, model, host, onProgress);
        return String(text || '').replace(/\s+/g, ' ').trim();
      } catch (e) {
        log('Worker 方式失败（源=' + host + '）：' + ((e && e.message) || e), 'error');
      }
    }

    // 兜底：主线程推理（页面可能短暂卡顿）
    log('改为在主线程推理（转写期间页面可能卡顿）…', 'error');
    const transcriber = await getTranscriberMain(model, onProgress);
    log('语音模型就绪，开始转写…');
    const res = await transcriber(f32, { chunk_length_s: 30, stride_length_s: 5, return_timestamps: false });
    return ((res && res.text) || '').replace(/\s+/g, ' ').trim();
  }

  /** 各 frame 收到转写指令后执行 */
  let _transcribing = false;
  async function handleTranscribe() {
    if (_transcribing) { log('已有转写任务在进行中，请稍候；若长时间无反应请刷新页面', 'error'); return; }
    _transcribing = true;
    try {
      const cfg = getConfig();
      const manual = (cfg.audioUrl || '').trim();
      if (manual && !IS_TOP) return; // 手动 URL 只由顶层执行，避免多 frame 重复转写
      const url = manual || detectAudioUrl();
      if (!url) { log('未在当前页面找到音频，请在面板手动填写音频URL', 'error'); return; }
      log('准备转写音频：' + url.slice(0, 90) + (url.length > 90 ? '…' : ''));
      const text = await withTimeout(transcribeAudio(url, async function (oldUrl) {
        if (manual) return oldUrl; // 手动 URL 无法可靠推断新地址，仅用最新登录态重试
        await sleep(0.5);
        const fresh = detectAudioUrl();
        if (fresh) rememberAudioMeta(fresh, location.href);
        return fresh || oldUrl;
      }), 600000, '转写超时（10分钟）');
      if (!text) { log('转写结果为空，请重试或改用更准确的模型', 'error'); return; }
      if (IS_TOP) applyTranscript(text, url);
      else {
        try { window.top.postMessage({ __cxfill: true, type: 'transcript', text, url }, '*'); } catch (e) { /* ignore */ }
      }
    } catch (e) {
      const msg = (e && e.message) ? e.message : String(e);
      const hint = isAuthDownloadError(e)
        ? '（音频访问被服务器拒绝：请先确认网页播放器能正常播放，再重试）'
        : '（若发生在模型加载阶段，可尝试切换「模型源」）';
      log('音频转写失败：' + msg + hint, 'error');
      if (!IS_TOP) {
        try { window.top.postMessage({ __cxfill: true, type: 'transcript-error', message: msg }, '*'); } catch (err) { /* ignore */ }
      }
    } finally {
      _transcribing = false;
    }
  }

  /** 顶层应用转写结果（手动流程） */
  function applyTranscript(text, url) {
    _lastTranscript = text;
    saveOriginal(text);
    saveConfig({ audioUrl: url || getConfig().audioUrl || '' });
    updatePreview(text, []);
    log('转写完成（' + text.length + ' 字符），已填入「原文」框，请核对后填空', 'success');
    broadcast({ __cxfill: true, type: 'fill', text });
  }

  /* -------------------------------------------------------------------------
   * 任务状态机（AudioTask[]）
   *   章节 → 扫描音频 → 建立任务队列 → 逐条「转写→匹配→填空」→ 全部完成→下一章
   * -----------------------------------------------------------------------*/

  const Tasks = { chapterId: '', list: [], current: -1 };
  let _seqToken = 0;        // 中断令牌
  let _seqRunning = false;
  let _lastTranscript = '';
  let _collecting = false;
  let _collected = [];
  let _fillWaiters = {};

  const TASK_STATUS_LABEL = {
    pending: '待处理', transcribing: '转写中', transcribed: '已转写',
    matching: '匹配中', filled: '已填写', error: '出错'
  };

  function postToTop(obj) {
    try { window.top.postMessage(Object.assign({ __cxfill: true }, obj), '*'); } catch (e) { /* ignore */ }
  }

  /** 计算当前 frame 在窗口树中的位置（如 "0.1"），用于跨域上报时稳定排序 */
  function framePath() {
    try {
      const parts = [];
      let w = window;
      while (w && w.parent && w.parent !== w) {
        const p = w.parent;
        let idx = 0;
        try {
          const n = p.frames.length;
          for (let i = 0; i < n; i++) { if (p.frames[i] === w) { idx = i; break; } }
        } catch (e) { /* ignore */ }
        parts.unshift(idx);
        w = p;
      }
      return parts.join('.');
    } catch (e) { return ''; }
  }

  /** 按窗口树路径排序（顶层为空路径，排最前） */
  function compareFramePath(a, b) {
    const toArr = (s) => String(s || '').split('.').filter((x) => x !== '').map(Number);
    const pa = toArr(a);
    const pb = toArr(b);
    const n = Math.min(pa.length, pb.length);
    for (let i = 0; i < n; i++) { if (pa[i] !== pb[i]) return pa[i] - pb[i]; }
    return pa.length - pb.length;
  }

  /** 每个 frame：把自己页面里的音频地址汇报给顶层（带窗口树路径） */
  function reportAudioList() {
    try {
      const urls = detectAudioUrls();
      if (urls.length) {
        const items = urls.map(function (u) { return { url: u, referer: audioReferer(u) }; });
        postToTop({ type: 'audio-list', urls: urls, items: items, path: framePath() });
      }
    } catch (e) { /* ignore */ }
  }

  function newTask(index, url) {
    return { index: index, url: url, status: 'pending', transcript: '', positions: [], match: null, filled: false, confidence: 0, model: '' };
  }

  function taskLabel(i) { return '音频 ' + (i + 1); }

  function buildTasks(urls) {
    Tasks.list = urls.map(function (u, i) { return newTask(i + 1, u); });
    Tasks.current = Tasks.list.length ? 0 : -1;
    renderTaskUI();
    if (Tasks.current >= 0) showTaskTranscript(Tasks.current);
  }

  /** 音频地址显示用的短名 */
  function shortUrl(u) {
    try {
      const clean = String(u).split('?')[0].split('#')[0];
      const parts = clean.split('/');
      const name = decodeURIComponent(parts[parts.length - 1] || clean);
      return name.length > 48 ? name.slice(0, 48) + '…' : (name || String(u).slice(0, 48));
    } catch (e) { return String(u).slice(0, 48); }
  }

  /** 顶层：向所有 frame 收集音频，并与确定性遍历结果合并（遍历结果在前，顺序稳定） */
  async function collectAllAudio() {
    const deterministic = collectChapterAudio();
    _collected = [];
    _collecting = true;
    broadcast({ __cxfill: true, type: 'collect-audio' });
    await sleep(1.2);
    _collecting = false;
    const merged = deterministic.slice();
    // 跨域 frame 通过消息上报，按窗口树路径排序后追加，保证顺序稳定
    _collected
      .slice()
      .sort(function (a, b) { return compareFramePath(a && a.path, b && b.path); })
      .forEach(function (item) {
        ((item && item.items) || []).forEach(function (it) {
          if (it && it.url) rememberAudioMeta(it.url, it.referer || '');
        });
        ((item && item.urls) || []).forEach(function (u) { if (u && merged.indexOf(u) === -1) merged.push(u); });
      });
    return merged;
  }

  /** 403/401 后重新扫描章节，按任务序号取得最新临时音频 URL */
  async function refreshTaskAudioUrl(i, oldUrl) {
    if (!IS_TOP) return oldUrl || '';
    try {
      log('检测到音频鉴权失败，正在重新扫描本章音频地址…', 'info');
      let urls = [];
      for (let attempt = 0; attempt < 3; attempt++) {
        urls = await collectAllAudio();
        if (urls.length > i) break;
        await sleep(0.8);
      }
      const fresh = urls[i] || '';
      if (!fresh) {
        log('重新扫描后仍未取得当前音频地址', 'error');
        return oldUrl || '';
      }
      if (Tasks.list[i]) {
        Tasks.list[i].url = fresh;
        renderTaskUI();
      }
      if (fresh !== oldUrl) log('已取得新的临时音频地址，将自动重试', 'success');
      else log('重新扫描后地址未变化，仍尝试用最新登录态重试一次', 'info');
      return fresh;
    } catch (e) {
      log('刷新音频地址失败：' + ((e && e.message) || e), 'error');
      return oldUrl || '';
    }
  }

  /** 顶层：扫描章节内所有音频，建立任务队列 */
  async function scanChapter() {
    if (!IS_TOP) return;
    Tasks.chapterId = chapterKey();
    let urls = [];
    // 题目/iframe 异步加载时音频可能稍后才出现，多试几次
    for (let attempt = 0; attempt < 4; attempt++) {
      urls = await collectAllAudio();
      if (urls.length) break;
      await sleep(1.2);
    }
    buildTasks(urls);
    if (Tasks.list.length) {
      log('章节扫描完成：共 ' + Tasks.list.length + ' 个音频任务');
      Tasks.list.forEach(function (t, i) { log('  ' + taskLabel(i) + ' ← ' + shortUrl(t.url)); });
    } else {
      log('章节扫描完成：未检测到音频（页面若仍在加载，请稍后点「重新扫描」）', 'error');
    }
  }

  function renderTaskUI() {
    if (!IS_TOP) return;
    const sel = document.getElementById('cx-task-select');
    if (sel) {
      const cur = Tasks.current;
      sel.innerHTML = '';
      Tasks.list.forEach(function (t, i) {
        const o = document.createElement('option');
        o.value = String(i);
        o.textContent = taskLabel(i) + '（' + (TASK_STATUS_LABEL[t.status] || t.status) + '）';
        if (t.url) o.title = shortSafeUrl(t.url); // 不在 DOM 暴露临时签名参数
        sel.appendChild(o);
      });
      if (cur >= 0 && cur < Tasks.list.length) sel.value = String(cur);
    }
    const listBox = document.getElementById('cx-task-list');
    if (listBox) {
      listBox.innerHTML = Tasks.list.map(function (t, i) {
        const cls = t.status === 'filled' ? 'done' : (t.status === 'transcribing' || t.status === 'matching' ? 'doing' : '');
        let mark = TASK_STATUS_LABEL[t.status] || t.status;
        if (t.status === 'filled') mark += '（' + Math.round((t.confidence || 0) * 100) + '%）';
        return '<div class="cx-task ' + cls + (i === Tasks.current ? ' active' : '') + '">● ' + taskLabel(i) + ' — ' + mark + '</div>';
      }).join('');
    }
    const prog = document.getElementById('cx-task-progress');
    if (prog) {
      const doneN = Tasks.list.filter(function (t) { return t.status === 'filled'; }).length;
      const total = Tasks.list.length;
      prog.textContent = '当前状态：' + (Tasks.current >= 0 ? taskLabel(Tasks.current) : '--') + ' / ' + total + '　已完成 ' + doneN + '/' + total;
      const inner = document.getElementById('cx-bar-inner');
      if (inner) inner.style.width = (total ? Math.round(doneN / total * 100) : 0) + '%';
    }
    const ch = document.getElementById('cx-chapter');
    if (ch) ch.textContent = '当前章节：' + (Tasks.chapterId ? Tasks.chapterId.split('|')[0].replace(/^https?:\/\//, '').slice(0, 48) : '--');
  }

  /** 顶层：显示某个任务的原文（命中答案按空加粗编号） */
  function showTaskTranscript(i) {
    if (!IS_TOP) return;
    const t = Tasks.list[i];
    if (!t) return;
    if (t.transcript && t.match && t.match.groups && t.match.groups.length) {
      _lastTranscript = t.transcript;
      let html = renderPreviewGroups(t.transcript, t.match.groups);
      const unsafe = t.match.groups.filter(function (g) { return g.reliable === false || !(g.words && g.words.length); });
      if (unsafe.length) {
        html += '<div class="cx-gap-warning">⚠ 转写可能缺失：第 ' +
          unsafe.map(function (g) { return escapeHtml(String(g.no)); }).join('、') +
          ' 空未自动填写，请人工核对音频。</div>';
      }
      setStyledOriginal(html, t.transcript);
    } else if (t.transcript) {
      _lastTranscript = t.transcript;
      setPlainOriginal(t.transcript);
    } else {
      setPlainOriginal('');
    }
    renderTaskUI();
  }

  /** 顶层：转写某个任务；转写完成后立即匹配算答案并标红 */
  async function transcribeTask(i) {
    if (!IS_TOP) return '';
    const t = Tasks.list[i];
    if (!t) return '';
    if (t.transcript) {
      // 已有转写：直接显示；若还没有匹配结果，补算一次
      if (!t.match || t.match.transcript !== t.transcript) await matchTask(i);
      else showTaskTranscript(i);
      return t.transcript;
    }
    t.status = 'transcribing';
    t.match = null;
    renderTaskUI();
    log('转写 ' + taskLabel(i) + '：' + shortSafeUrl(t.url));
    try {
      const text = await withTimeout(transcribeAudio(t.url, async function (oldUrl) {
        const fresh = await refreshTaskAudioUrl(i, oldUrl);
        if (fresh && Tasks.list[i]) Tasks.list[i].url = fresh;
        return fresh || oldUrl;
      }), 900000, '转写超时');
      if (!text) { t.status = 'error'; renderTaskUI(); log('转写为空', 'error'); return ''; }
      t.transcript = text;
      t.model = WHISPER_MODEL;
      t.status = 'transcribed';
      if (Tasks.current === i) showTaskTranscript(i); else renderTaskUI();
      // 转写完成 → 立即匹配算答案并标红（只算不写）
      await matchTask(i);
      return text;
    } catch (e) {
      t.status = t.transcript ? 'transcribed' : 'error';
      renderTaskUI();
      log('转写失败：' + ((e && e.message) || e), 'error');
      return '';
    }
  }

  /**
   * 广播一次匹配填空，汇总所有 frame 的结果，返回填写最多的那一个。
   * 有 frame 真正填入立即返回；否则等各 frame 回传「安静」一小段时间后返回，避免空等超时。
   */
  function runFillBroadcast(i, text) {
    return new Promise(function (resolve) {
      broadcast({ __cxfill: true, type: 'fill-task', taskIndex: i, text: text });
      const state = { best: null, groups: [], resolve: resolve, settleTimer: null, maxTimer: null, finish: null };
      state.finish = function () {
        if (_fillWaiters[i] !== state) return;
        delete _fillWaiters[i];
        clearTimeout(state.settleTimer);
        clearTimeout(state.maxTimer);
        resolve(state);
      };
      state.maxTimer = setTimeout(state.finish, 30000);
      _fillWaiters[i] = state;
    });
  }

  /** 顶层：把某个任务事先匹配好的答案填入题目（只写入，不重新匹配、不转写） */
  async function fillTask(i) {
    if (!IS_TOP) return 0;
    const t = Tasks.list[i];
    if (!t) return 0;
    let text = t.transcript || (Tasks.current === i ? readOriginal() : '');
    if (!text) { log('没有可用的原文，请先转写', 'error'); return 0; }

    // 还没有匹配结果 / 原文变了 / 上次没匹配到 → 重新匹配算答案
    if (!t.match || t.match.transcript !== cleanOriginalText(text) || !t.match.groups.length) {
      await matchTask(i, text);
    }
    // matchTask 会把原文清洗（去掉答案序号）后写回 t.transcript，之后一律用清洗后的原文
    text = t.transcript || cleanOriginalText(text);
    if (!t.match || !t.match.groups.length) {
      t.status = 'transcribed';
      renderTaskUI();
      log('未匹配到答案（' + taskLabel(i) + '）', 'error');
      return 0;
    }

    t.status = 'matching';
    renderTaskUI();
    const state = await runFillBroadcast(i, text);
    const r = state.best;
    const conf = (r && r.words) ? (r.matched / r.words) : 0;

    // 若答题区出现后重新对齐过，用实际写入的分组刷新标红，保证「标红 = 填入」
    if (state.groups && state.groups.length) {
      const groups = numberGroups(mergeGroups(t.match ? t.match.groups : [], state.groups));
      t.match = {
        transcript: text, groups: groups,
        totalBlanks: r ? (r.totalBlanks || 0) : 0,
        matched: r ? (r.matched || 0) : 0,
        wordCount: r ? (r.words || 0) : 0,
      };
      t.positions = groups.reduce(function (acc, g) { return acc.concat(g.positions || []); }, []);
    }

    if (r && r.filled > 0) {
      t.filled = true;
      t.confidence = conf;
      t.status = 'filled';
      if (Tasks.current === i) showTaskTranscript(i); else renderTaskUI();
      log('已填写 ' + taskLabel(i) + '：' + r.filled + '/' + (r.totalBlanks || '?') + ' 个空', 'success');
      return r.filled;
    }
    t.status = 'transcribed';
    renderTaskUI();
    if (r && r.totalBlanks === 0) {
      log('未找到答题输入框（答题区可能还没加载），请稍后重试', 'error');
    } else {
      log('未匹配到答案（' + taskLabel(i) + '）', 'error');
    }
    return 0;
  }

  /** 顶层：自动模式——逐条「转写→匹配→填空」 */
  async function runAutoAll() {
    if (!IS_TOP) return;
    _seqToken++; // 中断上一轮（序列只由顶层运行，无需广播，避免自我中断）
    if (_seqRunning) log('已中断上一轮，开始新一轮…', 'info');
    _seqRunning = true;
    const token = ++_seqToken;
    try {
      if (!Tasks.list.length) await scanChapter();
      if (!Tasks.list.length) { log('未检测到音频任务', 'error'); return; }
      for (let i = 0; i < Tasks.list.length; i++) {
        if (token !== _seqToken) { log('已取消当前自动流程', 'error'); return; }
        const t = Tasks.list[i];
        if (t.status === 'filled') continue;
        Tasks.current = i;
        renderTaskUI();
        const text = await transcribeTask(i);
        if (token !== _seqToken) return;
        if (!text) continue;
        await fillTask(i);
        if (token !== _seqToken) return;
        await sleep(1);
      }
      const allDone = Tasks.list.length > 0 && Tasks.list.every(function (t) { return t.status === 'filled'; });
      log(allDone ? '所有音频任务已完成' : '部分音频任务未完成，请查看日志', allDone ? 'success' : 'error');
    } finally {
      _seqRunning = false;
    }
  }

  /** 顶层：清空状态，准备新一章 */
  function resetForNewChapter() {
    if (!IS_TOP) return;
    _seqToken++; // 中断正在进行的旧序列，避免串音/串题
    Tasks.list = []; Tasks.current = -1; Tasks.chapterId = '';
    _collected = [];
    // 先把挂起的填空等待者放行，避免换章时 promise 永远悬空
    Object.keys(_fillWaiters).forEach(function (k) {
      const st = _fillWaiters[k];
      if (st && typeof st.finish === 'function') { try { st.finish(); } catch (e) { /* ignore */ } }
    });
    _fillWaiters = {};
    Object.keys(_matchWaiters).forEach(function (k) {
      const st = _matchWaiters[k];
      if (st && typeof st.finish === 'function') { try { st.finish(); } catch (e) { /* ignore */ } }
    });
    _matchWaiters = {};
    saveConfig({ originalText: '', originalTextChapter: '', audioUrl: '' });
    setPlainOriginal('');
    renderTaskUI();
    // 通知各 frame 丢弃旧章节的匹配缓存（含已失效的 DOM 引用）
    broadcast({ __cxfill: true, type: 'clear-match' });
    log('新章节：已清空任务与原文，开启新一轮', 'success');
  }

  /** 顶层：点击「下一章」 */
  function clickNextChapter() {
    if (!IS_TOP) return;
    let btn = document.querySelector('.nextChapter') || document.querySelector('a.nextChapter');
    if (!btn) {
      try {
        const cands = Array.from(document.querySelectorAll('a,button,div,span'));
        btn = cands.find(function (el) { return /下一章|下一节|下一单元|下一页/.test((el.textContent || '').trim()) && el.offsetParent !== null; });
      } catch (e) { /* ignore */ }
    }
    if (btn) {
      log('本轮任务完成，自动进入下一章…', 'success');
      setTimeout(function () { try { btn.click(); } catch (e) { log('点击下一章失败：' + e.message, 'error'); } }, 1500);
    } else {
      log('未找到「下一章」按钮，可能已是最后一章', 'error');
    }
  }

  /* -------------------------------------------------------------------------
   * 任务点完成检测 + 自动下一章
   *   —— 只有章节内「所有任务点」都变为已完成，才进入下一章
   * -----------------------------------------------------------------------*/

  function getChapterJobIcons() {
    try {
      const f = document.querySelector('#iframe');
      const doc = f && f.contentWindow && f.contentWindow.document;
      if (!doc) return null;
      return Array.from(doc.querySelectorAll('.ans-job-icon'));
    } catch (e) { return null; }
  }

  let _nextMonitor = null;
  let _nextClicked = false;
  function startNextChapterMonitor() {
    if (!IS_TOP || _nextMonitor) return;
    _nextMonitor = setInterval(() => {
      if (!getConfig().autoNext || _nextClicked) return;
      let jobs = null;
      try { jobs = getChapterJobIcons(); } catch (e) { /* ignore */ }
      if (!jobs || !jobs.length) return; // 非章节页 / 尚未加载
      const unfinished = jobs.filter((j) => !(j.parentElement && j.parentElement.classList.contains('ans-job-finished')));
      if (unfinished.length === 0) {
        _nextClicked = true;
        clearInterval(_nextMonitor); _nextMonitor = null;
        log('所有任务点已完成，自动进入下一章', 'success');
        resetForNewChapter();
        clickNextChapter();
      }
    }, 3000);
  }

  /* -------------------------------------------------------------------------
   * 原文预览：把命中的答案加粗并编号
   * -----------------------------------------------------------------------*/

  function escapeHtml(s) {
    return String(s).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
  }

  function renderPreview(text, positions) {
    const uniq = Array.from(new Set(positions.filter((p) => p >= 0))).sort((a, b) => a - b);
    const numByPos = {};
    uniq.forEach((p, i) => { numByPos[p] = i + 1; });
    let out = '';
    let last = 0;
    let idx = 0;
    const re = new RegExp(WORD_RE.source, 'g');
    let m;
    while ((m = re.exec(text)) !== null) {
      out += escapeHtml(text.slice(last, m.index));
      const w = m[0];
      if (numByPos[idx] != null) out += '<b class="cx-ans">' + numByPos[idx] + '. ' + escapeHtml(w) + '</b>';
      else out += escapeHtml(w);
      last = m.index + w.length;
      idx++;
    }
    out += escapeHtml(text.slice(last));
    return out;
  }

  /**
   * 按「空」分组渲染预览：一个空的多个词作为一个整体、标同一个编号，
   * 与填空时「一个空填一个短语」保持完全一致。
   * groups: [{ no, words:[], positions:[] }]，positions 为原文词下标。
   */
  function renderPreviewGroups(text, groups) {
    const map = {}; // 原文词下标 -> { g, first }
    (groups || []).forEach(function (g) {
      (g.positions || []).forEach(function (p, k) {
        if (p >= 0) map[p] = { g: g, first: (k === 0) };
      });
    });

    let out = '';
    let last = 0;
    let idx = 0;
    const re = new RegExp(WORD_RE.source, 'g');
    let m;
    while ((m = re.exec(text)) !== null) {
      const hit = map[idx];
      if (hit && !hit.first) {
        // 组内后续词：连同其前面的空白一起吞掉，避免被拆成多个编号/多出空格
        last = m.index + m[0].length;
        idx++;
        continue;
      }
      out += escapeHtml(text.slice(last, m.index));
      if (hit && hit.first) {
        const words = (hit.g.words && hit.g.words.length) ? hit.g.words : [m[0]];
        out += '<b class="cx-ans">' + hit.g.no + '. ' + words.map(escapeHtml).join(' ') + '</b>';
      } else {
        out += escapeHtml(m[0]);
      }
      last = m.index + m[0].length;
      idx++;
    }
    out += escapeHtml(text.slice(last));
    return out;
  }

  /** 保存「原文」并记录其所属章节；换章后旧原文自动失效 */
  function saveOriginal(text) {
    const val = (text == null) ? '' : String(text);
    saveConfig({ originalText: val, originalTextChapter: val.trim() ? chapterKey() : '' });
  }

  /** 顶层：把「原文」区显示为纯文本（手动输入时） */
  function setPlainOriginal(text) {
    if (!IS_TOP) return;
    const box = document.getElementById('cx-fill-original');
    if (!box) return;
    box.dataset.styled = '0';
    box.textContent = text || '';
  }

  /** 顶层：把「原文」区显示为带样式的文本（答案加粗编号） */
  function setStyledOriginal(html, plainText) {
    if (!IS_TOP) return;
    const box = document.getElementById('cx-fill-original');
    if (!box) return;
    box.dataset.styled = '1';
    box.innerHTML = html || '';
    if (plainText != null) saveOriginal(plainText);
  }

  /** 读取当前「原文」的纯文本（用于对齐） */
  function readOriginal() {
    const box = document.getElementById('cx-fill-original');
    if (box && box.dataset.styled !== '1') return (box.innerText || '').trim();
    return (getConfig().originalText || '').trim();
  }

  /** 渲染并展示「原文」（命中答案加粗编号）；非顶层则转发给顶层 */
  function updatePreview(text, positions) {
    if (!text) return;
    const html = renderPreview(text, positions || []);
    if (IS_TOP) setStyledOriginal(html, text);
    else postToTop({ type: 'preview', html, text });
  }

  /* =========================================================================
   * 六、执行流程
   * =======================================================================*/

  /* -------------------------------------------------------------------------
   * 匹配（只算不写） 与 写入（只写不算）
   *
   * 转写完成后立即「匹配」：算出每个空的答案与原文位置，存到任务上并标红；
   * 点「填空」时只「写入」已算好的答案，不再重新匹配，更不再重新转写/下载音频。
   * 这样标红与填入用的是同一份结果，天然一致。
   * -----------------------------------------------------------------------*/

  // 每个 frame：taskIndex -> { text, results }
  let _matchCache = {};
  let _matchWaiters = {};

  /**
   * 从「题干」解析片段并匹配（不看答题输入框）。
   * 结果按「序号」分组：每个序号一组答案（可能是一段短语），对应一个输入框。
   */
  function matchStem(container, text) {
    let frag;
    try { frag = extractFragment(container, 0); } catch (e) { return null; }
    const fragText = frag ? frag.text : '';
    if (!fragText || !tokenize(fragText).length) return null;

    const ma = matchAnswers(fragText, text);

    // 匹配质量门槛：原文与题干几乎对不上时跳过，避免填入无关内容
    const fragWordCount = ma.wordCount || 0;
    const matchRatio = fragWordCount ? (ma.matched || 0) / fragWordCount : 0;
    const qualityOk = fragWordCount > 0 && ((matchRatio >= 0.4 && (ma.matched || 0) >= 3) || (fragWordCount <= 3 && matchRatio >= 0.9));
    if (!qualityOk) {
      log('原文与本题匹配度过低（' + Math.round(matchRatio * 100) + '%），已跳过', 'info');
      return null;
    }
    if (!ma.groups.length) return null;

    const unsafe = ma.groups.filter(function (g) { return g.reliable === false; });
    if (unsafe.length) {
      log('检测到局部转写断层：第 ' + unsafe.map(function (g) { return g.no; }).join('、') + ' 空将自动跳过，防止答案错位', 'error');
    }
    log('答案预览：' + ma.groups.map(function (g) {
      if (g.reliable === false) return g.no + '.⚠跳过';
      return g.no + '.' + (g.words.join(' ') || '?');
    }).join('  '));

    return {
      container: container,
      groups: ma.groups,
      matched: ma.matched || 0,
      wordCount: fragWordCount,
      matchRatio: matchRatio,
    };
  }

  /** 匹配当前 frame 里所有填空题容器（只依赖题干，不写入） */
  function runMatch(text) {
    const containers = findContainers(document);
    const results = [];
    const groups = [];
    let totalBlanks = 0;
    let matchedSum = 0;
    let wordSum = 0;

    containers.forEach(function (container, ci) {
      const m = matchStem(container, text);
      if (!m) return;
      m.container = container;
      m.ci = ci;
      results.push(m);
      totalBlanks += m.groups.length;
      matchedSum += m.matched;
      wordSum += m.wordCount;
      m.groups.forEach(function (g, bi) {
        groups.push({
          path: framePath(), ci: ci, bi: bi, no: g.no,
          words: (g.words || []).slice(), positions: (g.positions || []).slice(),
          reliable: g.reliable !== false, reason: g.reason || ''
        });
      });
    });

    return { results: results, groups: groups, totalBlanks: totalBlanks, matched: matchedSum, wordCount: wordSum };
  }

  /**
   * 把匹配结果写入输入框（只写不算）。
   * 每个「序号」是一组答案（可能多词），按序号顺序对应到输入框：
   * 第 k 组（序号）→ 第 k 个输入框，整组短语一起填入。数量不一致时只填能对上的并提示核对。
   */
  async function writeMatch(results) {
    let filled = 0;
    let totalBlanks = 0;
    let matchedSum = 0;
    let wordSum = 0;
    const usedPositions = [];
    const groups = [];

    for (const m of results) {
      let editors = [];
      try { editors = findBlankEditors(m.container); } catch (e) { editors = []; }
      if (!editors.length) continue; // 答题区还没出现：不影响标红，仅跳过写入

      const gs = m.groups || [];
      const n = Math.min(editors.length, gs.length);
      if (editors.length !== gs.length) {
        log('序号数（' + gs.length + '）与输入框数（' + editors.length + '）不一致，按顺序只填前 ' + n + ' 个，请核对', 'error');
      }

      const hasTextarea = editors.some(function (e) { return (e.tagName || '').toLowerCase() === 'textarea'; });
      if (hasTextarea) await ensureUE(3000);

      totalBlanks += editors.length;
      matchedSum += m.matched || 0;
      wordSum += m.wordCount || 0;

      const interval = Number(getConfig().answerInterval) || 1;
      let skipped = 0;
      let unsafeSkipped = 0;
      const unsafeNos = [];
      for (let i = 0; i < n; i++) {
        const g = gs[i] || {};
        // 局部断裂的空绝不写入，也绝不清空原有内容。
        if (g.reliable === false) {
          skipped++; unsafeSkipped++; unsafeNos.push(g.no != null ? g.no : (i + 1));
          continue;
        }
        const val = (g.words || []).join(' ');
        if (!val) { skipped++; continue; }
        const ok = setBlankValue(editors[i], val, PAGE);
        if (ok) {
          filled++;
          const ps = g.positions || [];
          for (let q = 0; q < ps.length; q++) if (ps[q] >= 0) usedPositions.push(ps[q]);
        }
        if (i < n - 1) await sleep(interval);
      }
      if (unsafeSkipped) log('为防止错位，已跳过疑似转写缺失的第 ' + unsafeNos.join('、') + ' 空', 'error');
      if (skipped > unsafeSkipped) log('另有 ' + (skipped - unsafeSkipped) + ' 个空未匹配到答案，已跳过（不清空）', 'error');

      // 所有分组都回传（包括空答案/不可靠组），这样后续编号与输入框位置不会发生前移。
      gs.forEach(function (g, bi) {
        groups.push({
          path: framePath(), ci: m.ci, bi: bi, no: g.no,
          words: (g.words || []).slice(), positions: (g.positions || []).slice(),
          reliable: g.reliable !== false, reason: g.reason || ''
        });
      });
    }
    return { filled: filled, positions: usedPositions, totalBlanks: totalBlanks, matched: matchedSum, words: wordSum, groups: groups };
  }

  /** 按（窗口路径 → 容器序号 → 空序号）合并分组，后者覆盖前者 */
  function mergeGroups(base, add) {
    const map = {};
    const key = function (g) { return (g.path || '') + '|' + (g.ci || 0) + '|' + (g.bi || 0); };
    (base || []).forEach(function (g) { map[key(g)] = g; });
    (add || []).forEach(function (g) { map[key(g)] = g; });
    return Object.keys(map).map(function (k) { return map[k]; });
  }

  /** 顶层：把各 frame 的分组按（窗口路径 → 容器序号 → 空序号）排序；编号沿用题干序号，缺失时兜底自增 */
  function numberGroups(rawGroups) {
    const groups = (rawGroups || []).slice().sort(function (a, b) {
      const c = compareFramePath(a.path, b.path);
      if (c) return c;
      if ((a.ci || 0) !== (b.ci || 0)) return (a.ci || 0) - (b.ci || 0);
      return (a.bi || 0) - (b.bi || 0);
    });
    let seq = 0;
    groups.forEach(function (g) {
      seq++;
      if (g.no == null || g.no === '' || isNaN(g.no)) g.no = seq;
    });
    return groups;
  }

  /** 顶层：广播匹配（只算不写），汇总各 frame 结果 */
  function runMatchBroadcast(i, text) {
    return new Promise(function (resolve) {
      broadcast({ __cxfill: true, type: 'match-task', taskIndex: i, text: text });
      const state = { groups: [], totalBlanks: 0, matched: 0, wordCount: 0, has: false, resolve: resolve, settleTimer: null, maxTimer: null, finish: null };
      state.finish = function () {
        if (_matchWaiters[i] !== state) return;
        delete _matchWaiters[i];
        clearTimeout(state.settleTimer);
        clearTimeout(state.maxTimer);
        resolve(state);
      };
      state.maxTimer = setTimeout(state.finish, 10000);
      _matchWaiters[i] = state;
    });
  }

  /** 顶层：匹配某个任务 → 存到任务上（含按空分组的答案与位置）→ 标红 */
  async function matchTask(i, textOverride) {
    if (!IS_TOP) return null;
    const t = Tasks.list[i];
    if (!t) return null;
    let text = textOverride || t.transcript || '';
    if (!text) return null;
    // 匹配前统一清洗原文：去掉答案键里的序号（1. 2. …），避免它们被当成词
    text = cleanOriginalText(text);

    t.status = 'matching';
    renderTaskUI();
    const state = await runMatchBroadcast(i, text);
    const groups = numberGroups(state.groups);

    t.transcript = text;
    t.match = { transcript: text, groups: groups, totalBlanks: state.totalBlanks || 0, matched: state.matched || 0, wordCount: state.wordCount || 0 };
    t.positions = groups.reduce(function (acc, g) { return acc.concat(g.positions || []); }, []);
    t.status = 'transcribed';
    if (Tasks.current === i) showTaskTranscript(i); else renderTaskUI();
    log(groups.length ? ('匹配完成：共标注 ' + groups.length + ' 个答案') : '未匹配到答案（请核对原文与题目是否对应）', groups.length ? 'success' : 'error');
    return t.match;
  }

  let _lastChapterKey = '';

  /**
   * 从 URL 里取「章节」标识。
   * 只认 chapterId：nodeId 是章内知识点的编号，同章内切换音频也会变，
   * 若把它算进来会误判为换章、把已填任务清空。
   */
  function chapterIdOf(url) {
    try {
      const m = /[?&]chapterId=([^&#]+)/i.exec(String(url || ''));
      return m ? decodeURIComponent(m[1]) : '';
    } catch (e) { return ''; }
  }

  /** 章节标识：优先用章节 id，避免同一章内 iframe 重载被误判为换章 */
  function chapterKey() {
    try {
      const f = document.querySelector('#iframe') || document.querySelector('iframe');
      let inner = '';
      if (f) {
        try { inner = (f.contentWindow && f.contentWindow.location && f.contentWindow.location.href) || f.src || ''; }
        catch (e) { inner = f.src || ''; }
      }
      const id = chapterIdOf(location.href) || chapterIdOf(inner);
      if (id) return 'id:' + id;
      let innerPath = inner;
      try { innerPath = new URL(inner, location.href).pathname; } catch (e) { /* ignore */ }
      return 'u:' + location.pathname + '|' + innerPath;
    } catch (e) { return 'u:' + location.href; }
  }

  /** 顶层：检测到换章时的统一处理（清空 → 重新扫描 → 按需自动处理） */
  let _chapterSwitching = false;
  function onChapterChanged() {
    if (!IS_TOP || _chapterSwitching) return;
    _chapterSwitching = true;
    setTimeout(function () { _chapterSwitching = false; }, 2500);
    _nextClicked = false;
    resetForNewChapter();
    (async function () {
      await scanChapter();
      if (getConfig().audioAuto) runAutoAll();
    })();
    if (getConfig().autoNext) startNextChapterMonitor();
  }

  /** 等待题目出现后执行一次，并做周期性检查（SPA/iframe 异步加载） */
  async function bootstrapFrame() {
    const cfg = getConfig();

    if (IS_TOP) {
      // 清理不属于本章的残留原文，避免把上一章转写结果填入本章
      const savedText = (cfg.originalText || '').trim();
      const savedKey = cfg.originalTextChapter || '';
      if (savedText && savedKey !== chapterKey()) {
        saveOriginal('');
        log('检测到上一章残留原文，已清空', 'info');
      }
    }

    if (IS_TOP && cfg.audioAuto) {
      // 仅当用户显式勾选「自动填写」时才自动开始，避免无操作却自动转写/填空
      resetForNewChapter();
      setTimeout(function () { runAutoAll(); }, 3000);
    } else if (IS_TOP) {
      // 手动模式：仅扫描音频建立任务队列，绝不自动转写或填写
      setTimeout(function () { if (!Tasks.list.length) scanChapter(); }, 1500);
    }

    // 顶层：启动了自动下一章的话，持续监测任务点完成情况
    if (IS_TOP && cfg.autoNext) startNextChapterMonitor();

    // 顶层：章节切换检测 → 清空并开启新一轮（不再依赖是否勾选自动模式）
    if (IS_TOP && !bootstrapFrame._chapterTimer) {
      _lastChapterKey = chapterKey();
      const startAt = Date.now();
      bootstrapFrame._chapterTimer = setInterval(function () {
        const k = chapterKey();
        if (k === _lastChapterKey) return;
        // 初始加载期间 iframe 尚未就绪，只更新基准，不当作换章
        if (Date.now() - startAt < 6000) { _lastChapterKey = k; return; }
        _lastChapterKey = k;
        log('检测到章节切换，已重新扫描音频', 'info');
        onChapterChanged();
      }, 3000);
    }
  }

  /* =========================================================================
   * 七、顶层面板 UI（仅顶层窗口创建）
   * =======================================================================*/

  const PANEL_CSS = `
    #cx-fill-toggle{position:fixed;right:20px;bottom:20px;z-index:999999;width:52px;height:52px;border:none;border-radius:50%;
      background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;font-size:20px;font-weight:700;cursor:pointer;
      box-shadow:0 6px 16px rgba(0,0,0,.25);transition:transform .2s;}
    #cx-fill-toggle:hover{transform:scale(1.08);}
    #cx-fill-panel{position:fixed;right:20px;bottom:84px;z-index:999999;width:520px;max-width:92vw;background:#fff;border-radius:14px;
      box-shadow:0 12px 40px rgba(0,0,0,.25);font-family:system-ui,-apple-system,"Microsoft YaHei",sans-serif;color:#303133;overflow:hidden;}
    #cx-fill-panel.cx-hidden{display:none;}
    #cx-fill-panel .cx-head{display:flex;align-items:center;justify-content:space-between;padding:12px 16px;
      background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;font-weight:600;font-size:15px;}
    #cx-fill-panel .cx-close{cursor:pointer;font-size:20px;line-height:1;opacity:.9;}
    #cx-fill-panel .cx-body{padding:14px 16px;max-height:70vh;overflow:auto;}
    #cx-fill-panel label{display:block;font-size:13px;font-weight:600;margin:8px 0 6px;}
    #cx-fill-panel textarea{width:100%;height:180px;box-sizing:border-box;border:1px solid #dcdfe6;border-radius:8px;padding:10px;
      font-size:13px;line-height:1.6;resize:vertical;outline:none;}
    #cx-fill-panel textarea:focus{border-color:#764ba2;}
    #cx-fill-panel .cx-row{display:flex;align-items:center;gap:10px;margin-top:10px;flex-wrap:wrap;}
    #cx-fill-panel button{cursor:pointer;border:none;border-radius:8px;padding:8px 14px;font-size:13px;font-weight:600;transition:.2s;}
    #cx-fill-panel .cx-primary{background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;}
    #cx-fill-panel .cx-primary:hover{opacity:.9;}
    #cx-fill-panel .cx-ghost{background:#f2f3f5;color:#303133;}
    #cx-fill-panel .cx-input,#cx-fill-panel select.cx-select{width:100%;box-sizing:border-box;border:1px solid #dcdfe6;border-radius:8px;
      padding:8px 10px;font-size:13px;outline:none;margin-bottom:8px;background:#fff;color:#303133;}
    #cx-fill-panel .cx-input:focus,#cx-fill-panel select.cx-select:focus{border-color:#764ba2;}
    #cx-fill-panel .cx-sep{margin:14px 0 8px;padding-top:12px;border-top:1px solid #ebeef5;font-size:13px;font-weight:600;color:#606266;}
    #cx-fill-panel .cx-original{width:100%;height:170px;box-sizing:border-box;border:1px solid #dcdfe6;border-radius:8px;padding:10px;
      font-size:13px;line-height:1.9;overflow:auto;outline:none;white-space:pre-wrap;word-break:break-word;color:#303133;background:#fff;}
    #cx-fill-panel .cx-original:focus{border-color:#764ba2;}
    #cx-fill-panel .cx-original:empty::before{content:attr(data-ph);color:#a8abb2;}
    #cx-fill-panel .cx-original .cx-ans{color:#c0392b;font-weight:700;}
    #cx-fill-panel .cx-gap-warning{margin-top:10px;padding:8px 10px;border-radius:6px;background:#fff4e5;color:#b26a00;font-weight:600;font-size:12px;line-height:1.6;}
    #cx-fill-panel .cx-log{margin-top:12px;background:#1e1e1e;border-radius:8px;padding:10px;height:150px;overflow:auto;
      font-family:Consolas,Monaco,monospace;font-size:12px;line-height:1.6;}
    #cx-fill-panel .cx-log div{color:#d4d4d4;}
    #cx-fill-panel .cx-log .success{color:#67c23a;}
    #cx-fill-panel .cx-log .error{color:#f56c6c;}
    #cx-fill-panel .cx-log .info{color:#409eff;}
    #cx-fill-panel .cx-chapter{font-size:13px;color:#606266;margin:4px 0;}
    #cx-fill-panel .cx-tasklist{margin:6px 0 4px;max-height:130px;overflow:auto;}
    #cx-fill-panel .cx-task{font-size:12px;color:#909399;padding:2px 0;}
    #cx-fill-panel .cx-task.done{color:#67c23a;}
    #cx-fill-panel .cx-task.doing{color:#409eff;font-weight:600;}
    #cx-fill-panel .cx-task.active{color:#764ba2;font-weight:700;}
    #cx-fill-panel .cx-bar{height:6px;background:#f0f2f5;border-radius:3px;overflow:hidden;margin:4px 0 8px;}
    #cx-fill-panel .cx-bar>div{height:100%;width:0;background:linear-gradient(90deg,#667eea,#764ba2);transition:width .3s;}
    #cx-fill-panel .cx-progress-text{font-size:12px;color:#606266;}
  `;

  function addStyle(css) {
    try {
      if (typeof GM_addStyle === 'function') { GM_addStyle(css); return; }
    } catch (e) { /* ignore */ }
    const style = document.createElement('style');
    style.textContent = css;
    (document.head || document.documentElement).appendChild(style);
  }

  let _lastLogMsg = '';
  let _lastLogTime = 0;

  function appendLog(msg, level) {
    try {
      // 抑制 3 秒内重复的相同日志（多个 iframe 会各报一次）
      const now = Date.now();
      if (msg === _lastLogMsg && now - _lastLogTime < 3000) return;
      _lastLogMsg = msg;
      _lastLogTime = now;

      const box = document.getElementById('cx-fill-log');
      if (!box) return;
      const line = document.createElement('div');
      line.className = level || 'info';
      line.textContent = '[' + new Date().toLocaleTimeString() + '] ' + msg;
      box.appendChild(line);
      while (box.childNodes.length > 60) box.removeChild(box.firstChild);
      box.scrollTop = box.scrollHeight;
    } catch (e) { /* ignore */ }
  }

  function broadcast(msg) {
    const seen = new Set();
    (function walk(win) {
      if (!win || seen.has(win)) return;
      seen.add(win);
      try { win.postMessage(msg, '*'); } catch (e) { /* ignore */ }
      let n = 0;
      try { n = win.frames.length; } catch (e) { return; }
      for (let i = 0; i < n; i++) {
        try { walk(win.frames[i]); } catch (e) { /* ignore */ }
      }
    })(window.top || window);
  }

  function buildPanel() {
    if (!IS_TOP) return;
    if (document.getElementById('cx-fill-root')) return;

    addStyle(PANEL_CSS);
    const cfg = getConfig();

    const root = document.createElement('div');
    root.id = 'cx-fill-root';
    root.innerHTML = `
      <button id="cx-fill-toggle" title="英语听力填空助手">填</button>
      <div id="cx-fill-panel" class="cx-hidden">
        <div class="cx-head"><span>英语听力填空助手</span><span class="cx-close" id="cx-fill-close">×</span></div>
        <div class="cx-body">
          <div id="cx-chapter" class="cx-chapter">当前章节：--</div>

          <div class="cx-sep">听力任务</div>
          <select id="cx-task-select" class="cx-select"></select>
          <div id="cx-task-list" class="cx-tasklist"></div>
          <div class="cx-row">
            <button class="cx-primary" id="cx-fill-transcribe">转写当前音频</button>
            <button class="cx-primary" id="cx-fill-runfill">扫描并填空</button>
            <button class="cx-ghost" id="cx-fill-refresh">重新扫描</button>
          </div>
          <div class="cx-row">
            <label style="margin:0;font-weight:400;"><input type="checkbox" id="cx-fill-audioauto"> 自动填写（逐条转写+填空）</label>
            <label style="margin:0;font-weight:400;"><input type="checkbox" id="cx-fill-autonext"> 完成后自动下一章</label>
          </div>
          <div class="cx-row">
            <span style="font-size:12px;color:#606266;">模型 small.en（最准）</span>
            <span style="font-size:12px;color:#606266;">源</span>
            <select id="cx-fill-modelhost" class="cx-select" style="width:auto;margin-bottom:0;">
              <option value="https://hf-mirror.com">国内镜像</option>
              <option value="https://huggingface.co">官方</option>
            </select>
          </div>

          <div id="cx-task-progress" class="cx-progress-text">当前状态：--</div>
          <div class="cx-bar"><div id="cx-bar-inner"></div></div>

          <div class="cx-sep">原文（命中答案加粗标红并编号）</div>
          <div id="cx-fill-original" class="cx-original" contenteditable="true" data-ph="选择音频后点「转写当前音频」，或在此粘贴原文"></div>
          <div class="cx-row">
            <button class="cx-ghost" id="cx-fill-debug">调试</button>
            <button class="cx-ghost" id="cx-fill-clear">清空</button>
          </div>

          <div class="cx-log" id="cx-fill-log"></div>
        </div>
      </div>`;
    (document.body || document.documentElement).appendChild(root);

    const panel = document.getElementById('cx-fill-panel');
    const originalBox = document.getElementById('cx-fill-original');

    // 只恢复「本章」的原文；上一章/无归属的残留一律清掉，避免误填
    if (cfg.originalText && cfg.originalTextChapter === chapterKey()) {
      setPlainOriginal(cfg.originalText);
    } else if (cfg.originalText) {
      saveOriginal('');
    }
    originalBox.dataset.styled = '0';

    // 手动编辑后按纯文本处理，并同步保存（同时更新当前任务的原文）
    originalBox.addEventListener('input', () => {
      originalBox.dataset.styled = '0';
      const val = (originalBox.innerText || '').trim();
      saveOriginal(val);
      const t = (Tasks.current >= 0) ? Tasks.list[Tasks.current] : null;
      // 原文被手动改动 → 之前的匹配结果作废，下次填空会重新匹配
      if (t) { t.transcript = val; t.match = null; t.positions = []; }
    });

    const taskSel = document.getElementById('cx-task-select');
    const hostSel = document.getElementById('cx-fill-modelhost');
    const audioAutoBox = document.getElementById('cx-fill-audioauto');
    const autoNextBox = document.getElementById('cx-fill-autonext');
    hostSel.value = cfg.modelHost || 'https://hf-mirror.com';
    if (!hostSel.value) hostSel.value = 'https://hf-mirror.com';
    audioAutoBox.checked = !!cfg.audioAuto;
    autoNextBox.checked = !!cfg.autoNext;

    document.getElementById('cx-fill-toggle').addEventListener('click', () => {
      panel.classList.toggle('cx-hidden');
      if (!panel.classList.contains('cx-hidden')) {
        renderTaskUI();
        if (!Tasks.list.length) scanChapter();
      }
    });
    document.getElementById('cx-fill-close').addEventListener('click', () => panel.classList.add('cx-hidden'));

    taskSel.addEventListener('change', () => {
      Tasks.current = parseInt(taskSel.value, 10) || 0;
      showTaskTranscript(Tasks.current);
    });
    document.getElementById('cx-fill-transcribe').addEventListener('click', async () => {
      saveConfig({ modelHost: hostSel.value, audioAuto: audioAutoBox.checked, autoNext: autoNextBox.checked });
      if (!Tasks.list.length) await scanChapter();
      if (Tasks.current < 0) { log('没有可转写的音频，请先点「重新扫描」', 'error'); return; }
      await transcribeTask(Tasks.current);
    });
    document.getElementById('cx-fill-runfill').addEventListener('click', async () => {
      if (!Tasks.list.length) await scanChapter();
      if (Tasks.current < 0) {
        // 没有音频任务：用「原文」框里手动粘贴的文本填空
        const t = readOriginal();
        if (!t) { log('没有可填空的原文，请先转写或粘贴原文', 'error'); return; }
        broadcast({ __cxfill: true, type: 'fill', text: t });
        return;
      }
      const cur = Tasks.list[Tasks.current];
      if (!cur.transcript && readOriginal()) cur.transcript = readOriginal();
      await fillTask(Tasks.current);
    });
    document.getElementById('cx-fill-refresh').addEventListener('click', async () => {
      log('重新扫描章节音频…', 'info');
      await scanChapter();
    });
    document.getElementById('cx-fill-debug').addEventListener('click', () => {
      log('正在收集题目HTML，请稍候…', 'info');
      broadcast({ __cxfill: true, type: 'debug' });
    });
    document.getElementById('cx-fill-clear').addEventListener('click', () => {
      setPlainOriginal('');
      saveOriginal('');
      const t = (Tasks.current >= 0) ? Tasks.list[Tasks.current] : null;
      if (t) { t.transcript = ''; t.match = null; t.positions = []; }
      log('已清空原文', 'success');
    });
    hostSel.addEventListener('change', () => saveConfig({ modelHost: hostSel.value }));
    audioAutoBox.addEventListener('change', () => {
      saveConfig({ audioAuto: audioAutoBox.checked });
      if (audioAutoBox.checked) runAutoAll();
    });
    autoNextBox.addEventListener('change', () => saveConfig({ autoNext: autoNextBox.checked }));

    try {
      if (typeof GM_registerMenuCommand === 'function') {
        GM_registerMenuCommand('打开/关闭英语填空助手', () => panel.classList.toggle('cx-hidden'));
      }
    } catch (e) { /* ignore */ }
  }

  /* =========================================================================
   * 八、消息监听与启动
   * =======================================================================*/

  window.addEventListener('message', (e) => {
    const d = e.data;
    if (!d || !d.__cxfill) return;
    if (d.type === 'match-task') {
      // 只匹配、不写入；结果缓存起来供后续填空复用
      (function () {
        let m;
        try { m = runMatch(d.text); } catch (e) { m = { results: [], groups: [], totalBlanks: 0, matched: 0, wordCount: 0 }; }
        _matchCache[d.taskIndex] = { text: d.text, results: m.results };
        postToTop({
          type: 'match-result', taskIndex: d.taskIndex, groups: m.groups, has: m.results.length > 0,
          totalBlanks: m.totalBlanks, matched: m.matched, wordCount: m.wordCount,
        });
      })();
    } else if (d.type === 'match-result' && IS_TOP) {
      const st = _matchWaiters[d.taskIndex];
      if (!st || typeof st.finish !== 'function') return;
      if (Array.isArray(d.groups)) st.groups = st.groups.concat(d.groups);
      st.totalBlanks += d.totalBlanks || 0;
      st.matched += d.matched || 0;
      st.wordCount += d.wordCount || 0;
      if (d.has) st.has = true;
      clearTimeout(st.settleTimer);
      st.settleTimer = setTimeout(st.finish, 1200);
    } else if (d.type === 'fill') {
      // 无任务的手动粘贴原文：现算一次匹配，再写入
      (async () => {
        const m = runMatch(d.text);
        await writeMatch(m.results);
      })();
    } else if (d.type === 'fill-task') {
      (async () => {
        const cached = _matchCache[d.taskIndex];
        let results;
        if (cached && cached.text === d.text) {
          results = cached.results;
        } else {
          const m = runMatch(d.text);
          _matchCache[d.taskIndex] = { text: d.text, results: m.results };
          results = m.results;
        }
        const r = await writeMatch(results);
        postToTop({
          type: 'fill-result', taskIndex: d.taskIndex, has: results.length > 0,
          filled: (r && r.filled) || 0, positions: (r && r.positions) || [],
          totalBlanks: (r && r.totalBlanks) || 0, matched: (r && r.matched) || 0, words: (r && r.words) || 0,
          groups: (r && r.groups) || [],
        });
      })();
    } else if (d.type === 'fill-result' && IS_TOP) {
      const st = _fillWaiters[d.taskIndex];
      if (!st || typeof st !== 'object' || typeof st.finish !== 'function') return;
      const res = {
        filled: d.filled || 0, positions: d.positions || [], totalBlanks: d.totalBlanks || 0,
        matched: d.matched || 0, words: d.words || 0, has: d.has === true,
      };
      if (!st.best || res.filled > st.best.filled) st.best = res;
      if (Array.isArray(d.groups)) st.groups = st.groups.concat(d.groups);
      // 有 frame 真正填入立即返回；否则等待所有 frame 回传后「安静」一段时间再返回
      if (st.best && st.best.filled > 0) { st.finish(); return; }
      clearTimeout(st.settleTimer);
      st.settleTimer = setTimeout(st.finish, 2500);
    } else if (d.type === 'collect-audio') {
      reportAudioList();
    } else if (d.type === 'audio-list' && IS_TOP) {
      if (_collecting) _collected.push({ path: d.path || '', urls: d.urls || [], items: d.items || [] });
    } else if (d.type === 'preview' && IS_TOP) {
      setStyledOriginal(d.html, d.text);
    } else if (d.type === 'abort') {
      _seqToken++;
    } else if (d.type === 'clear-match') {
      // 换章：丢弃旧章节的匹配缓存（含已失效的 DOM 引用）
      _matchCache = {};
    } else if (d.type === 'transcribe') {
      handleTranscribe();
    } else if (d.type === 'transcript' && IS_TOP) {
      applyTranscript(d.text, d.url);
    } else if (d.type === 'transcript-error' && IS_TOP) {
      log('音频转写失败：' + d.message, 'error');
    } else if (d.type === 'log' && IS_TOP) {
      appendLog(d.msg, d.level);
    } else if (d.type === 'debug') {
      const cs = findContainers(document);
      if (!cs.length) return;
      cs.slice(0, 5).forEach((c, i) => {
        log('调试 容器' + (i + 1) + '：<' + c.tagName.toLowerCase() + ' class="' + (c.className || '') + '"> 输入框=' + findBlankEditors(c).length);
        log('  文本：' + (c.innerText || '').replace(/\s+/g, ' ').slice(0, 120));
      });
      try {
        window.top.postMessage({ __cxfill: true, type: 'debug-html', html: cs[0].outerHTML }, '*');
      } catch (err) { /* ignore */ }
    } else if (d.type === 'debug-html' && IS_TOP) {
      window.__cxDebugHTML = d.html;
      console.log('[填空助手] 题目HTML（已保存到 window.__cxDebugHTML）：\n' + d.html);
      const manual = () => {
        try { window.prompt('自动复制失败，请全选复制下面的题目HTML：', d.html); } catch (err) { /* ignore */ }
      };
      try {
        navigator.clipboard.writeText(d.html).then(
          () => appendLog('题目HTML已复制到剪贴板（长度 ' + d.html.length + '），请粘贴给开发者', 'success'),
          () => { appendLog('剪贴板写入失败，已弹出文本框供手动复制', 'error'); manual(); }
        );
      } catch (err) {
        appendLog('剪贴板不可用，已弹出文本框供手动复制', 'error');
        manual();
      }
    }
  });

  if (IS_TOP) {
    buildPanel();
  }
  bootstrapFrame();

})();