From 31a2640adbddeec244463c58704ca1ac8eae0185 Mon Sep 17 00:00:00 2001
From: suanyuit-cyber <346708943+suanyuit-cyber@users.noreply.github.com>
Date: Fri, 30 Oct 2026 03:34:38 +0800
Subject: [PATCH] fix: require evidence for judgment answers and correct legacy
banks
---
README.md | 35 +-
build.cjs | 2 +-
dist/huayi-question-bank.user.js | 235 +-
package.json | 2 +-
scripts/merge-question-banks.cjs | 34 +-
scripts/select-bank-snapshots.cjs | 9 +-
src/adapter.js | 35 +-
src/app.js | 103 +-
src/core.js | 95 +-
tests/adapter.test.cjs | 139 +-
tests/core.test.cjs | 193 +
tests/integration.test.cjs | 128 +-
tests/select-bank-snapshots.test.cjs | 105 +-
题库/README.md | 57 +-
.../华谊集团化工总控工（高级）-判断题库1_500题.csv | 1000 +-
.../华谊集团化工总控工（高级）-判断题库2_232题.csv | 464 +-
题库/华谊集团化工总控工（高级）-合并题库.csv | 1464 +-
题库/华谊集团化工总控工（高级）-合并题库.json | 11712 +++-------------
题库/导出批次核对.json | 9 +-
题库/答案来源更正_20261030.json | 89 +
题库/题库清单.json | 75 +-
21 files changed, 4875 insertions(+), 11110 deletions(-)
create mode 100644 题库/答案来源更正_20261030.json
diff --git a/README.md b/README.md
index 4c76fd5..9cbe448 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,16 @@
# 华谊题库助手
-支持在普通 HTTP / HTTPS 网页中通过快捷键打开的本地题库油猴脚本：文字搜索、划词检索、自动选择已确认答案，并保留华谊练习平台的按库采集、CSV 导出与多题库导入。当前版本 **1.2.5**。
+支持在普通 HTTP / HTTPS 网页中通过快捷键打开的本地题库油猴脚本：文字搜索、划词检索、自动选择已确认答案，并保留华谊练习平台的按库采集、CSV 导出与多题库导入。当前版本 **1.2.6**。
+
+**2026-10-30 答案来源更正：此前“1884题标准答案全部确认”的结论错误。** Chrome 实际练习和页面业务代码均证实，`/upm/start`、`/upm/wrong/start` 的未作答判断题也可能带有默认 `judgeAnswer: 0`，该值不能视为标准“错误”；旧值为 `1` 且没有提交或标准反馈证据时也不能确认。1.2.6 将这类旧判断题答案改为“待补”，清除仅由列表占位值及其继承 DOM 观察造成的冲突，并保留原值备份。两个可信标准答案不一致时仍保留冲突。
+
+当前仓库保留五库 **1884个完整题目位置**，其中 **1153题答案已确认、731题待补、0题冲突**。已确认部分为单选500 + 401题、多选251题，以及判断题库1中经实际页面标准反馈单独核对的1题。题干和位置完整不代表答案完整；详情及逐项更正依据见 [`答案来源更正_20261030.json`](题库/答案来源更正_20261030.json)。
1.2.5 修复运行卡顿：题目与别名合并改为索引查找；无关计时器、答题卡选中样式和助手自身变化不再触发题目扫描；隐藏面板停止重建搜索及统计；重复浏览已保存题目跳过无效合并。题库保存按800ms合批并在浏览器空闲时执行，离开页面时立即写回；存储没有被其他标签页改变时直接保存已验证的内存记录，保留跨标签冲突、备份与迁移检查。
-本版同时保留已复现的切题保护：题目ID、选项ID和输入控件实际值均参与身份核对，点击前后等待异步渲染稳定；上一题残留的答案反馈不再套用到新题。自动选择仍默认关闭，题库文件及标准答案未修改。
+本版同时保留已复现的切题保护：题目ID、选项ID和输入控件实际值均参与身份核对，点击前后等待异步渲染稳定；上一题残留的答案反馈不再套用到新题。自动选择仍默认关闭。1.2.6 的题库答案来源更正与上述性能及切题保护一起生效。
-1.2.4 在完整选项ID与正文映射一致时，可准确对应文字相同的不同选项；ID变化且文字有歧义时继续跳过。新增对旧版乘号、正负号实体记录的有证据补全，保留原始备份。缺少题目位置等依据的旧记录继续保留，仓库中的五库全集使用各库最新、题数与索引均已核验的完整网络批次。
+1.2.4 在完整选项ID与正文映射一致时，可准确对应文字相同的不同选项；ID变化且文字有歧义时继续跳过。新增对旧版乘号、正负号实体记录的有证据补全，保留原始备份。缺少题目位置等依据的旧记录继续保留，五库题目集合按各库最新、题数与索引均已核验的完整题目批次整理；这里的完整仅指题干和位置，判断题答案来源另按1.2.6规则更正。
1.2.3 保留题干及选项中的图片地址，支持纯图片的化学结构式选项；修复多选题中多个正确选项文字相同而误报冲突的问题。只有部分同文选项正确、无法确定位置时仍跳过。图片题的答案继续按选项 ID 对应，CSV / JSON 保留图片来源地址；CSV 本身不嵌入图片像素。
@@ -14,14 +18,14 @@
安装文件：[`dist/huayi-question-bank.user.js`](dist/huayi-question-bank.user.js)。这是构建后的完整脚本，无须安装 Node.js 或运行服务器。
-五个题库已于2026-10-29从Chrome导出并合并为 **1884题**，标准答案全部确认。可直接使用 [`合并CSV`](题库/华谊集团化工总控工（高级）-合并题库.csv) 或 [`JSON备份`](题库/华谊集团化工总控工（高级）-合并题库.json)；独立分库、31张原图和校验清单见 [`题库说明`](题库/README.md)。
+五个题库于2026-10-29从Chrome导出，2026-10-30更正判断题答案来源后仍保留 **1884题**。可使用 [`合并CSV`](题库/华谊集团化工总控工（高级）-合并题库.csv) 或 [`JSON备份`](题库/华谊集团化工总控工（高级）-合并题库.json)；两份文件均明确保留731题待补状态。独立分库、31张原图和校验清单见 [`题库说明`](题库/README.md)。
## 安装与开始使用
1. 在浏览器中安装并启用 Tampermonkey（油猴）。
2. 打开油猴管理面板，选择“新建脚本”，将安装文件的全部内容粘贴进去并保存。
3. 打开或刷新普通网页，按 **Shift + Alt + Q** 显示题库助手，再按一次隐藏。每次加载页面都默认完全隐藏，无悬浮按钮；旧版保存的打开状态也会重置。
-4. 在华谊练习页面，正常加载的题目和标准答案仍会自动保存；安装后应重新进入练习，以便观察首次题目响应。普通网页只使用本地题库检索，不观察其网络请求或自动采集表单。
+4. 在华谊练习页面，正常加载的题目会自动保存；只有取得可信提交记录或标准反馈时才保存已确认答案。安装后应重新进入练习，以便观察首次题目响应。普通网页只使用本地题库检索，不观察其网络请求或自动采集表单。
5. 在“文字搜索”中输入或粘贴至少两个字符，按回车或点“搜索”。也可以在页面划选题干后松开鼠标自动查询。
6. 在“题库 / 导出”中检查实际题库名、范围内题数及文件名预览，再导出 CSV 或备份 JSON。已识别的练习页默认当前题库；普通网页默认全部已存题库。
@@ -41,6 +45,8 @@
## 自动答题
+旧判断题库中未获可信反馈的题目显示“待补”，不会自动选择。已有候选结果与“当前题对应”分别展示；相似搜索结果或候选记录不能代替当前题的完整题干、选项及身份核对。
+
打开“自动答题”页签，先导入包含标准答案的题库，然后选择：
- **答当前题**：从本地已确认记录中精确匹配当前题干、题型和完整选项，自动选择正确选项。
@@ -97,8 +103,11 @@
- 例如采集时正确答案为 B“提高温度”，当前页面该内容移至 C，面板显示“提高温度；当前页面对应：C”。
- 多选题保存正确选项的完整集合；判断题保存“正确 / 错误”。
- 未取得标准答案时显示“待补”。学生选择、答题卡上的对错和题号不会被当作标准答案。
+- 判断题列表的 `judgeAnswer` 值本身不构成标准答案证据。只有已提交列表、绑定到同题的作答回执、绑定当前题的标准反馈或明确标准答案源，才可恢复确认；分别保存为 `submitted-list`、`answer-response`、`bound-dom`、`explicit-standard`。
- 重复选项无法唯一对应、选项内容发生变化、同一题出现不同答案时，显示未确认或冲突，冲突内容保留在备份中。
+升级1.2.6后，助手在读取、导入及合并旧记录时检查判断题答案来源。首次更正前将原值保存到独立备份；可在“设置”或油猴菜单中选择“导出判断题核验前备份”取回。备份失败时停止覆盖原库。已有可信作答回执或明确标准反馈可以恢复答案，未取得证据的题目继续待补。该备份独立于重复记录整理、重复选项误报和图片补全备份。
+
## CSV 与 JSON
CSV 使用 UTF-8 BOM，兼容 Excel 查看，支持中文、逗号、双引号及单元格换行。列包括：来源题库、题库 ID、题目 ID、题型、题干、各选项、正确答案内容、采集时答案字母、解析、答案状态、答案来源、采集时间和完整记录 JSON。
@@ -115,7 +124,7 @@ CSV 使用 UTF-8 BOM，兼容 Excel 查看，支持中文、逗号、双引号
“正确答案内容”填写完整答案文字。多选使用 JSON 字符串数组或在同一单元格中逐行填写完整选项，不能仅填写 A/B 字母。“我的答案”列不作为标准答案读取。建议直接以助手导出的表格作为模板。
-JSON 备份包含 `schemaVersion: 1` 和 `records` 数组，保留完整选项标识、来源、答案和冲突。两种格式均按题目合并，导入不会清空现有题库。每个文件限制 20 MB，每批文件合计限制 50 MB、50000 条记录。
+JSON 备份包含 `schemaVersion: 1` 和 `records` 数组，保留完整选项标识、来源、答案、冲突和可选的 `answerEvidence` 证据字段；CSV的完整记录JSON列同样保留这些内容。两种格式均按题目合并，导入不会清空现有题库。导入旧版无证据网络判断题时仍会更正为待补；用户自行填写的标准CSV不因该旧网络规则被清空。每个文件限制 20 MB，每批文件合计限制 50 MB、50000 条记录。
## 采集范围与当前验证边界
@@ -123,24 +132,24 @@ JSON 备份包含 `schemaVersion: 1` 和 `records` 数组，保留完整选项
目前适配了保存页面中的真实题目结构，以及业务脚本中可确认的练习接口：`/upm/start`、`/upm/wrong/start`、`/pra/{id}/questions` 和对应单题作答结果。接口适配限制在本站及学习平台域名。脚本不发送题库到外部服务器，来源 URL 不保存查询参数。
-原保存HTML用于结构适配，原始网页及资源文件不纳入仓库；浏览器测试使用脱敏的最小题目结构夹具。2026-10-29已在实际登录的Chrome学习页面逐库验证：判断500/232题、单选500/401题、多选251题，正常加载的完整批次均包含标准答案，合并文件已按页面题数和完整题目位置核验。
+原保存HTML用于结构适配，原始网页及资源文件不纳入仓库；浏览器测试使用脱敏的最小题目结构夹具。2026-10-29在实际登录的Chrome学习页面核对了五库题数：判断500/232题、单选500/401题、多选251题，合并文件的题数和完整位置仍成立。此前把判断题完整列表中的默认值认定为标准答案，已于2026-10-30更正，不能再据此声称旧完整批次包含全部标准答案。
+
+实际Chrome核验的判断题库1第67题为“断续噪声与持续噪声相比，断续噪声对人体危害更大。”。只读查看已作答记录：提交答案为“错误”，网页标准答案为“正确”；仓库仅对这一题作明确的人工标准核验，并记录 `explicit-standard` 证据。其余731题不根据0、1或常识猜测答案。核验前原值保留在本地 `.cache/` 和 Git 提交 `4bf2de1` 中。
题库保存在油猴脚本存储中，关闭面板、刷新或暂停采集不会清空。更换浏览器、卸载脚本或清理扩展数据前，请先导出 JSON 备份。
## 源码与验证
-`题库/` 已保存从Chrome导出的五库及合并结果。批次选择工具仅接受时间最新、题数与页面一致且位置完整的网络批次，再由合并工具保留来源、标准答案、解析及ID别名并核对五库：
+`题库/` 已保存经过答案来源更正的五库及合并结果。当前答案尚未补齐，使用已更正的分库文件合并时需显式允许待补：
```powershell
-$rawBankExports = Get-ChildItem exports/browser-20261029 -Filter '*_v123.csv' -File
-npm run select:snapshots -- --manifest 题库/页面题数核对.json --force $rawBankExports.FullName
$bankCsvFiles = Get-ChildItem 题库/分题库 -Filter '*.csv' -File
-npm run merge:banks -- --manifest 题库/页面题数核对.json $bankCsvFiles.FullName
+npm run merge:banks -- --manifest 题库/页面题数核对.json --allow-partial --force $bankCsvFiles.FullName
```
-页面清单格式为 `{"banks":[{"bankName":"完整题库名称","questionCount":500}, ...]}`，需要列出判断1、判断2、单选1、单选2和多选五个题库。合并前会核对缺库、缺答案和冲突，详情写入输出的 `题库清单.json`；数据未齐时不标记为完整。
+页面清单格式为 `{"banks":[{"bankName":"完整题库名称","questionCount":500}, ...]}`，需要列出判断1、判断2、单选1、单选2和多选五个题库。合并前会核对缺库、缺答案和冲突，详情写入输出的 `题库清单.json`。当前 `questionsComplete: true`、`answersComplete: false`、`complete: false`；`--allow-partial` 仅允许输出如实标记待补的题库，不会把缺失答案变为已确认。不加该参数时应因答案未齐而失败。
-本次五份原始CSV含1899条缓存记录，选择五个最新完整批次后为1884题，15条历史表示版本保留在原始下载中；来源哈希与排除标识记在 `导出批次核对.json`。本地 `exports/` 不上传仓库，复现选择阶段需要保留原始CSV。再次生成已有合并文件时，可显式加 `--force` 覆盖本次固定输出。
+五份历史原始CSV含1899条缓存记录，按题干和位置整理后为1884题，15条历史表示版本保留在原始下载中；来源哈希与排除标识记在 `导出批次核对.json`。该历史批次核对只能证明题数和位置，不能证明判断题答案可信。对旧 `exports/browser-20261029/*_v123.csv` 重新执行 `select:snapshots` 应因判断题缺少可信标准答案而失败；`--force` 不会跳过核验，也不能恢复缺失的证据。后续只有重新采集到充分可信答案的新完整批次才能通过严格选择。本地 `exports/` 和 `.cache/` 不上传仓库。
无需第三方前端依赖，源码分为：
diff --git a/build.cjs b/build.cjs
index aa2373e..a4e8f2a 100644
--- a/build.cjs
+++ b/build.cjs
@@ -4,7 +4,7 @@ const root = __dirname;
const header = `// ==UserScript==
// @name 华谊题库助手 · CSV导出与划词检索
// @namespace local.huayi.question-bank
-// @version 1.2.5
+// @version 1.2.6
// @description 全网页快捷键唤出、本地题库文字检索与自动选择答案，按库导入导出；每页默认完全隐藏。
// @match *://*/*
// @run-at document-start
diff --git a/dist/huayi-question-bank.user.js b/dist/huayi-question-bank.user.js
index 22b1708..ea49e25 100644
--- a/dist/huayi-question-bank.user.js
+++ b/dist/huayi-question-bank.user.js
@@ -1,7 +1,7 @@
// ==UserScript==
// @name 华谊题库助手 · CSV导出与划词检索
// @namespace local.huayi.question-bank
-// @version 1.2.5
+// @version 1.2.6
// @description 全网页快捷键唤出、本地题库文字检索与自动选择答案，按库导入导出；每页默认完全隐藏。
// @match *://*/*
// @run-at document-start
@@ -23,6 +23,7 @@ const QBCore = (() => {
const TYPES = new Set(['single', 'multiple', 'judge', 'unknown']);
const STATUSES = new Set(['confirmed', 'missing', 'conflict']);
+ const ANSWER_EVIDENCE = new Set(['submitted-list', 'answer-response', 'bound-dom', 'explicit-standard']);
const TYPE_NAMES = { single: '单选题', multiple: '多选题', judge: '判断题', unknown: '未知' };
const STATUS_NAMES = { confirmed: '已确认', missing: '待补', conflict: '冲突' };
const own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
@@ -84,6 +85,7 @@ const QBCore = (() => {
const type = input.type == null ? 'unknown' : input.type;
if (!TYPES.has(type)) throw new Error(`不支持的题型：${text(type)}`);
if (input.answerStatus != null && !STATUSES.has(input.answerStatus)) throw new Error(`无效答案状态：${text(input.answerStatus)}`);
+ if (input.answerEvidence != null && !ANSWER_EVIDENCE.has(input.answerEvidence)) throw new Error(`无效答案证据：${text(input.answerEvidence)}`);
if (input.options != null && !Array.isArray(input.options)) throw new Error('选项必须是数组');
const options = (input.options || []).map((option, index) => {
if (typeof option === 'string') option = { text: option };
@@ -133,6 +135,7 @@ const QBCore = (() => {
}
}
if (own(input, 'questionIdAliases')) record.questionIdAliases = unique([...stringArray(input.questionIdAliases, '题目ID别名'), record.questionId].filter(Boolean));
+ if (input.answerEvidence != null) record.answerEvidence = input.answerEvidence;
if (input.answerSource || answerStatus === 'confirmed') record.answerSource = sourceInfo(input.answerSource || source);
record.key = recordKey(record);
return record;
@@ -148,6 +151,80 @@ const QBCore = (() => {
return JSON.stringify(sorted(record.correctOptionIds.map((value) => `id:${value}`)));
}
+ const answerProvenance = record => record?.answerSource || record?.source;
+ const legacyJudgeListSource = source => source?.kind === 'network' && /\/upm\/(?:wrong\/)?start(?:[?#]|$)/u.test(source.url || '');
+ const judgeAnswerResponseSource = source => source?.kind === 'network' && /\/upm\/[^/]+\/users\/[^/]+\/(?:wrong\/)?answer(?:[?#]|$)/u.test(source.url || '');
+ const trustedAnswerProvenance = record => ANSWER_EVIDENCE.has(record?.answerEvidence) || judgeAnswerResponseSource(answerProvenance(record)) ||
+ /^(?:csv-import|json-import|manual|manual-import|import)$/u.test(answerProvenance(record)?.kind || '');
+
+ // Old practice-list judgeAnswer values contained unsubmitted placeholders.
+ // This explicit migration preserves the raw input for a durable backup and
+ // touches only judge records with that evidenced legacy provenance or an
+ // unverified old DOM answer that could have inherited the same placeholder.
+ function repairLegacyJudgeAnswers(input) {
+ if (!Array.isArray(input)) throw new Error('题库必须是数组');
+ const changed = [];
+ const unverifiedLegacySource = record => (legacyJudgeListSource(answerProvenance(record)) || answerProvenance(record)?.kind === 'dom') && !trustedAnswerProvenance(record);
+ let records = input;
+ for (let index = 0; index < input.length; index++) {
+ const original = input[index];
+ if (original?.type !== 'judge') continue;
+ const snapshots = Array.isArray(original.conflicts) ? original.conflicts : [];
+ const contaminated = unverifiedLegacySource(original) && original.answerStatus !== 'missing' || snapshots.some(unverifiedLegacySource);
+ if (!contaminated) continue;
+ const record = normalizeRecord(original);
+ const candidates = [], unresolved = [];
+ const addCandidate = (candidate, snapshot) => {
+ if (unverifiedLegacySource(candidate)) return;
+ // An old DOM observation may merely have inherited the list value.
+ // Its presence in a contaminated record is not independent evidence.
+ if (!trustedAnswerProvenance(candidate)) {
+ const kind = answerProvenance(candidate)?.kind || 'unknown';
+ if (!['dom', 'unknown'].includes(kind)) unresolved.push(snapshot || conflictSnapshot(record, '未确认的判断题答案来源'));
+ return;
+ }
+ if (!candidate.answerTexts?.length && !candidate.correctOptionIds?.length) {
+ if (snapshot) unresolved.push(snapshot);
+ return;
+ }
+ try {
+ const source = answerProvenance(candidate);
+ const restored = normalizeRecord({ ...record, ...candidate, bankId: record.bankId, bankName: record.bankName,
+ questionId: record.questionId, source: record.source, answerSource: source,
+ answerEvidence: candidate.answerEvidence || (judgeAnswerResponseSource(source) ? 'answer-response' : undefined),
+ answerStatus: 'confirmed', conflicts: [] });
+ if (restored.answerStatus !== 'confirmed') {
+ if (snapshot) unresolved.push(snapshot);
+ else unresolved.push(conflictSnapshot(restored, '标准答案证据与选项不一致'));
+ } else candidates.push(restored);
+ } catch (_) { if (snapshot) unresolved.push(snapshot); }
+ };
+ for (const snapshot of snapshots) {
+ if (!snapshot || typeof snapshot !== 'object') continue;
+ addCandidate({ ...snapshot, answerEvidence: snapshot.answerEvidence }, snapshot);
+ }
+ if (record.answerStatus !== 'missing') addCandidate(record);
+ let repaired;
+ for (const candidate of candidates) repaired = repaired ? mergeNormalizedRecords(repaired, candidate) : candidate;
+ if (!repaired) repaired = normalizeRecord({ ...record, answerStatus: unresolved.length ? 'conflict' : 'missing',
+ answerTexts: [], correctOptionIds: [], answerSource: undefined, answerEvidence: undefined, conflicts: [] });
+ if (unresolved.length) repaired = normalizeRecord({ ...repaired, answerStatus: 'conflict',
+ conflicts: distinctConflicts([...repaired.conflicts, ...unresolved]) });
+ // Restore collection/identity metadata even when an older answer snapshot
+ // supplied the trustworthy stem, options and answer IDs atomically.
+ repaired = normalizeRecord({ ...record, ...repaired, source: record.source, updatedAt: record.updatedAt,
+ answerSource: repaired.answerSource, answerEvidence: repaired.answerEvidence,
+ questionIdAliases: record.questionIdAliases, questionIndex: record.questionIndex, contentOccurrence: record.contentOccurrence });
+ if (!own(record, 'questionIdAliases')) delete repaired.questionIdAliases;
+ if (JSON.stringify(repaired) === JSON.stringify(record)) continue;
+ if (records === input) records = input.slice();
+ records[index] = repaired;
+ changed.push({ index, key: record.key, reason: repaired.answerStatus === 'confirmed' ? 'recovered-proven-judge-answer' :
+ repaired.answerStatus === 'conflict' ? 'retained-proven-judge-conflict' : 'unverified-legacy-judge-answer', original });
+ }
+ return { records, changed };
+ }
+
// Old versions compared the list of ID-derived answers with a text set. When
// two correct options shared text, that comparison produced a false conflict.
// Repair only that evidenced shape; normalizeRecord keeps all other explicit
@@ -341,13 +418,16 @@ const QBCore = (() => {
}
function conflictSnapshot(record, reason) {
- return { reason, stem: record.stem, options: record.options.map((option) => ({ ...option })), answerTexts: [...record.answerTexts], correctOptionIds: [...record.correctOptionIds], source: record.answerSource || record.source };
+ const snapshot = { reason, stem: record.stem, options: record.options.map((option) => ({ ...option })), answerTexts: [...record.answerTexts], correctOptionIds: [...record.correctOptionIds], source: record.answerSource || record.source };
+ if (record.answerEvidence) snapshot.answerEvidence = record.answerEvidence;
+ return snapshot;
}
function distinctConflicts(conflicts) {
const byContent = new Map();
for (const item of conflicts) {
- const key = JSON.stringify([item.reason, item.stem, item.options, item.answerTexts, item.correctOptionIds]);
+ const key = JSON.stringify([item.reason, item.stem, item.options, item.answerTexts, item.correctOptionIds,
+ item.answerEvidence || '', item.source?.kind || '', item.source?.url || '']);
if (!byContent.has(key)) byContent.set(key, item);
}
return [...byContent.values()].slice(-40);
@@ -388,7 +468,7 @@ const QBCore = (() => {
if (newRecord.answerStatus !== 'missing') conflicts.push(conflictSnapshot(newRecord, reason));
const answerRecord = newRecord.answerStatus !== 'missing' ? newRecord : oldRecord;
return normalizeRecord({ ...base, answerTexts: answerRecord.answerTexts, correctOptionIds: answerRecord.correctOptionIds,
- answerSource: answerRecord.answerSource || answerRecord.source, answerStatus: 'conflict',
+ answerSource: answerRecord.answerSource || answerRecord.source, answerEvidence: answerRecord.answerEvidence, answerStatus: 'conflict',
conflicts: distinctConflicts(conflicts) });
}
if (newRecord.answerStatus === 'missing' && oldRecord.answerStatus === 'confirmed') {
@@ -396,6 +476,13 @@ const QBCore = (() => {
return normalizeRecord({ ...oldRecord, ...metadata, bankName: newRecord.bankName || oldRecord.bankName, explanation,
updatedAt: newRecord.updatedAt, source: newRecord.source, answerSource: oldRecord.answerSource || oldRecord.source });
}
+ if (oldRecord.type === 'judge' && oldRecord.answerStatus === 'confirmed' && newRecord.answerStatus === 'confirmed' &&
+ trustedAnswerProvenance(oldRecord) && !trustedAnswerProvenance(newRecord)) {
+ // Re-observing the same answer without evidence cannot replace the
+ // independently verified answer's provenance or its own option IDs.
+ return normalizeRecord({ ...oldRecord, ...metadata, bankName: newRecord.bankName || oldRecord.bankName, explanation,
+ updatedAt: newRecord.updatedAt, source: newRecord.source, answerSource: oldRecord.answerSource || oldRecord.source });
+ }
return normalizeRecord({ ...base, conflicts });
}
@@ -864,7 +951,7 @@ const QBCore = (() => {
return records;
}
- return { normalizeRecord, repairDuplicateOptionConflicts, upgradeLegacyImageRecords, upgradeLegacyMathEntities, mergeRecord, upsert, compactRecords, search, mapAnswers, toCSV, fromCSV };
+ return { normalizeRecord, repairLegacyJudgeAnswers, repairDuplicateOptionConflicts, upgradeLegacyImageRecords, upgradeLegacyMathEntities, mergeRecord, upsert, compactRecords, search, mapAnswers, toCSV, fromCSV };
})();
if (typeof module !== 'undefined' && module.exports) module.exports = QBCore;
@@ -939,14 +1026,24 @@ const QBAdapter = (() => {
function standardAnswer(node, type, options, context) {
const result = node.resultInfo && typeof node.resultInfo === 'object' ? node.resultInfo : null;
const answerNode = result || node;
- if ([node, answerNode].some(value => value.allowViewSingleQuesAnswer === false || value.allowViewSingleQuesAnswer === 0)) {
+ if (context.hideStandardAnswers || [node, answerNode].some(value => value.allowViewSingleQuesAnswer === false || value.allowViewSingleQuesAnswer === 0)) {
return { correctOptionIds: [], answerTexts: [], answerStatus: 'missing' };
}
+ const hasSubmitted = Array.isArray(node.submitQuesAnswers) && node.submitQuesAnswers.length > 0;
+ const verifiedResponse = context.answerResponse && context.questionId && context.knownQuestion;
+ const evidence = verifiedResponse ? 'answer-response' : hasSubmitted || result ? 'submitted-list' : 'explicit-standard';
+ if (context.answerResponse && !verifiedResponse) return { correctOptionIds: [], answerTexts: [], answerStatus: 'missing' };
if (type === 'judge') {
+ // /upm/start sends judgeAnswer=0 for unanswered listQues as well. The
+ // real client creates resultInfo only for non-empty submitQuesAnswers;
+ // reading that placeholder as an answer silently labels every new item false.
+ if ((context.practiceList || context.collection === 'listQues') && !hasSubmitted && !result && !verifiedResponse) {
+ return { correctOptionIds: [], answerTexts: [], answerStatus: 'missing' };
+ }
const raw = answerNode.judgeAnswer;
if (raw === 0 || raw === '0' || raw === 1 || raw === '1') {
const value = String(raw);
- return { correctOptionIds: [value], answerTexts: [value === '1' ? '正确' : '错误'], answerStatus: 'confirmed' };
+ return { correctOptionIds: [value], answerTexts: [value === '1' ? '正确' : '错误'], answerStatus: 'confirmed', answerEvidence: evidence };
}
} else {
let ids = [];
@@ -957,7 +1054,7 @@ const QBAdapter = (() => {
ids = [...new Set(ids)].filter(Boolean);
const resolved = ids.map(id => options.filter(o => o.id === id));
if (ids.length && resolved.every(matches => matches.length === 1) && (type !== 'single' || ids.length === 1)) {
- return { correctOptionIds: ids, answerTexts: resolved.map(matches => matches[0].text), answerStatus: 'confirmed' };
+ return { correctOptionIds: ids, answerTexts: resolved.map(matches => matches[0].text), answerStatus: 'confirmed', answerEvidence: evidence };
}
}
return { correctOptionIds: [], answerTexts: [], answerStatus: 'missing' };
@@ -998,7 +1095,7 @@ const QBAdapter = (() => {
if (options.length < 2 || options.some(o => !o.text)) return null;
} else if (previous) options = previous.options.map(o => ({ ...o }));
else return null;
- const answers = standardAnswer(node, type, options, context);
+ const answers = standardAnswer(node, type, options, { ...context, knownQuestion: previous });
const record = {
bankId: idString(node.praId || context.bankId || (previous && previous.bankId)),
bankName: text(context.bankName || (previous && previous.bankName)), questionId: id,
@@ -1029,7 +1126,9 @@ const QBAdapter = (() => {
for (const item of node.slice(0, 10000)) visit(item, arrayContext, depth + 1);
return;
}
- const next = { ...inherited, bankId: idString(node.praId || inherited.bankId), bankName: text(node.praName || inherited.bankName) };
+ const hidden = inherited.hideStandardAnswers || [node, node.info].some(value => value &&
+ (value.allowViewSingleQuesAnswer === false || value.allowViewSingleQuesAnswer === 0));
+ const next = { ...inherited, hideStandardAnswers: Boolean(hidden), bankId: idString(node.praId || inherited.bankId), bankName: text(node.praName || inherited.bankName) };
const isListContainer = ['listQues', 'questionList', 'questions'].some(key => Array.isArray(node[key]));
const candidate = isListContainer ? null : recordFromNode(node, next);
if (candidate) output.push(candidate);
@@ -1073,9 +1172,10 @@ const QBAdapter = (() => {
const praMatch = path.match(/\/pra\/([^/]+)\/questions/);
return {
// Retain no token-bearing query parameters in saved source URLs.
- url: url.origin + url.pathname,
+ url: url.origin + url.pathname.replace(/\/users\/[^/]+(?=\/)/, '/users/_'),
bankId: url.searchParams.get('praId') || (answerMatch && answerMatch[1]) || (praMatch && praMatch[1]) || '',
- answerResponse: Boolean(answerMatch)
+ answerResponse: Boolean(answerMatch),
+ practiceList: /\/upm\/(?:wrong\/)?start\/?$/.test(path)
};
} catch (_) { return null; }
}
@@ -1442,7 +1542,8 @@ const QBAdapter = (() => {
if (selected.length && (type !== 'single' || selected.length === 1)) {
const feedbackId = ['data-question-id', 'data-ques-id', 'question-id', 'ques-id']
.map(name => idString(row.getAttribute?.(name))).find(Boolean);
- const knownAnswer = matches.length === 1 && matches[0].answerStatus === 'confirmed' ? matches[0] : null;
+ const knownAnswer = matches.length === 1 && matches[0].answerStatus === 'confirmed' &&
+ ['submitted-list', 'answer-response', 'bound-dom', 'explicit-standard'].includes(matches[0].answerEvidence) ? matches[0] : null;
const agreesWithKnown = knownAnswer && knownAnswer.answerTexts.length === selected.length &&
selected.every(option => knownAnswer.answerTexts.some(answerText => flat(answerText) === flat(option.text)));
const boundToCurrent = q.questionId && feedbackId && feedbackId === q.questionId;
@@ -1450,6 +1551,7 @@ const QBAdapter = (() => {
q.correctOptionIds = selected.map(o => o.id).filter(Boolean);
q.answerTexts = selected.map(o => o.text);
q.answerStatus = 'confirmed';
+ q.answerEvidence = boundToCurrent ? 'bound-dom' : knownAnswer.answerEvidence;
}
} else if (heading === '解析' || heading === '试题解析' || heading === '答案解析') {
const feedbackId = ['data-question-id', 'data-ques-id', 'question-id', 'ques-id']
@@ -1473,6 +1575,10 @@ const QBAdapter = (() => {
function observePayload(payload, context) {
if (!active) return;
+ // A full list can replace the meaning of even an unchanged question ID.
+ // An older answer receipt has no independent stem/options to bind it to
+ // that new version; never fill it from the newer cached question.
+ if (context.answerResponse && (knownSnapshotOrder.get(context.bankId) || 0) > (context.requestSequence || 0)) return;
try {
const observedAt = new Date().toISOString();
const batchId = `${observedAt}:${++batchSequence}`;
@@ -1999,6 +2105,7 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
const BACKUP_KEY = 'huayi-qb.records.before-dedup.v1';
const OPTION_REPAIR_BACKUP_KEY = 'huayi-qb.records.before-duplicate-option-repair.v1';
const IMAGE_UPGRADE_BACKUP_KEY = 'huayi-qb.records.before-image-upgrade.v1';
+ const JUDGE_EVIDENCE_BACKUP_KEY = 'huayi-qb.records.before-judge-evidence-repair.v1';
const DEFAULTS = { mode: 'hidden', keepLauncher: false, copyEnabled: true, collecting: true, tab: 'search' };
const pageWindow = typeof unsafeWindow !== 'undefined' ? unsafeWindow : window;
const storage = {
@@ -2053,6 +2160,27 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
storage.set(OPTION_REPAIR_BACKUP_KEY, { schemaVersion: 1, savedAt: existing?.savedAt || new Date().toISOString(), records: originals });
return result;
}
+ function repairJudgeEvidence(original) {
+ const result = QBCore.repairLegacyJudgeAnswers(original);
+ if (!result.changed.length) return result;
+ const existing = storage.get(JUDGE_EVIDENCE_BACKUP_KEY, null);
+ if (existing !== null && (!existing || existing.schemaVersion !== 1 || !Array.isArray(existing.records))) {
+ throw new Error('判断题答案核验备份结构异常，已停止覆盖');
+ }
+ const originals = existing ? [...existing.records] : [];
+ const signatures = new Set(originals.map(record => JSON.stringify(record)));
+ for (const item of result.changed) {
+ const signature = JSON.stringify(item.original);
+ if (!signatures.has(signature)) { signatures.add(signature); originals.push(item.original); }
+ }
+ // Retain every previous value before cleared or restored answers reach persistence.
+ const backup = { schemaVersion: 1, savedAt: existing?.savedAt || new Date().toISOString(), records: originals };
+ storage.set(JUDGE_EVIDENCE_BACKUP_KEY, backup);
+ if (JSON.stringify(storage.get(JUDGE_EVIDENCE_BACKUP_KEY, null)) !== JSON.stringify(backup)) {
+ throw new Error('判断题答案核验备份未能完整保存，已停止覆盖');
+ }
+ return result;
+ }
function imageReplacementSignature(value, includeQuestionIdentity = true) {
const record = QBCore.normalizeRecord(value);
return JSON.stringify([includeQuestionIdentity ? record.key : record.bankId, record.type, record.stem,
@@ -2118,7 +2246,8 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
if (!Array.isArray(saved)) throw new Error('本地题库格式不正确');
storedRecordsText = JSON.stringify(saved);
const retained = removeBackedUpImagePredecessors(saved, saved);
- const repaired = repairAnswerConflicts(retained);
+ const judgeRepair = repairJudgeEvidence(retained);
+ const repaired = repairAnswerConflicts(judgeRepair.records);
const compacted = QBCore.compactRecords(QBCore.upsert([], repaired.records));
records = compacted.records;
const removed = retained.length - records.length;
@@ -2132,6 +2261,10 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
recordsDirty = true;
cleanupNotice += `${cleanupNotice ? ' ' : ''}已恢复 ${repaired.repaired.length} 道重复选项文字造成的答案误报，修复前记录已备份。`;
}
+ if (judgeRepair.changed.length) {
+ recordsDirty = true;
+ cleanupNotice += `${cleanupNotice ? ' ' : ''}已核验 ${judgeRepair.changed.length} 条判断题答案，缺少标准答案依据的记录已改为待补，原值已独立备份。`;
+ }
} catch (error) { loadError = `本地题库读取失败：${error.message}。请先保留已有备份。`; }
let root, shadow, panel, launcher, resultBox, statusBox;
let networkEnabled = ['www.shhuayi-elearning.cn', 'shhuayi-elearning.cn'].includes(window.location.hostname);
@@ -2196,9 +2329,9 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
// reconcile the whole library when another tab actually changed storage.
if (currentStoredText !== storedRecordsText) {
const retained = removeBackedUpImagePredecessors(stored, records);
- const compacted = QBCore.compactRecords(QBCore.upsert(repairAnswerConflicts(retained).records, records));
+ const compacted = QBCore.compactRecords(QBCore.upsert(repairAnswerConflicts(repairJudgeEvidence(retained).records).records, records));
if (compacted.removed > 0) ensureCleanupBackup(stored);
- records = repairAnswerConflicts(compacted.records).records;
+ records = repairAnswerConflicts(repairJudgeEvidence(compacted.records).records).records;
}
const nextStoredText = JSON.stringify(records);
if (nextStoredText !== currentStoredText) storage.set(RECORDS_KEY, records);
@@ -2243,7 +2376,7 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
try {
incoming = incoming.filter(record => !redundantDOMObservation(record));
if (!incoming.length) return;
- incoming = repairAnswerConflicts(incoming).records;
+ incoming = repairAnswerConflicts(repairJudgeEvidence(incoming).records).records;
const bank = currentBank();
const upgradeContext = {
bankId: !bank?.loading && (context.currentBankId || context.bankId) === bank?.bankId ? bank.bankId : '',
@@ -2271,7 +2404,7 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
const expanded = QBCore.upsert(records, incoming);
const compacted = QBCore.compactRecords(expanded);
if (compacted.removed > 0) ensureCleanupBackup(expanded);
- records = repairAnswerConflicts(compacted.records).records;
+ records = repairAnswerConflicts(repairJudgeEvidence(compacted.records).records).records;
recordsDirty = true;
schedulePersist();
renderVisible();
@@ -2449,11 +2582,38 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
shadow.getElementById('qb-auto-count').textContent = `本页已选择 ${state.answeredCount || 0} 题 · 已跳过 ${state.skippedCount || 0} 题`;
shadow.querySelector('[data-action="auto-answer-current"]').disabled = Boolean(state.busy);
}
+ function matchesCurrentQuestion(record, current) {
+ if (!current || record.type !== current.type) return false;
+ const flat = value => String(value || '').trim().replace(/\s+/gu, '');
+ const stem = value => flat(String(value || '').replace(/^(?:第\s*\d+\s*题[\s、.．:：]*|\d+\s*[、．]\s*|\d+\.\s+)/u, ''));
+ if (record.bankId && current.bankId && record.bankId !== current.bankId) return false;
+ if (!(record.bankId && record.bankId === current.bankId) && record.bankName && current.bankName &&
+ record.bankName !== '未命名题库' && current.bankName !== '未命名题库' && bankNameKey(record.bankName) !== bankNameKey(current.bankName)) return false;
+ if (Number.isSafeInteger(record.questionIndex) && Number.isSafeInteger(current.questionIndex) && record.questionIndex !== current.questionIndex) return false;
+ return stem(record.stem) === stem(current.stem) && JSON.stringify((record.options || []).map(option => flat(option.text)).sort()) ===
+ JSON.stringify((current.options || []).map(option => flat(option.text)).sort());
+ }
function renderResults() {
if (!resultBox || config.mode !== 'open' || config.tab !== 'search') return;
resultBox.replaceChildren();
const pool = scopedRecords(searchScope);
- const matches = query.trim() ? QBCore.search(pool, query, { limit: 50, field: searchField }) : [];
+ const current = currentQuestion();
+ const currentRecords = current ? pool.filter(record => matchesCurrentQuestion(record, current)) : [];
+ const matches = [];
+ if (query.trim()) {
+ const seen = new Set();
+ // A complete match to the displayed question precedes other keyword candidates.
+ for (const item of [...QBCore.search(currentRecords, query, { limit: 50, field: searchField }), ...QBCore.search(pool, query, { limit: 50, field: searchField })]) {
+ if (seen.has(item.record.key)) continue;
+ seen.add(item.record.key); matches.push(item);
+ if (matches.length === 50) break;
+ }
+ }
+ const confirmedCurrent = currentRecords.filter(record => record.answerStatus === 'confirmed')
+ .map(record => QBCore.mapAnswers(record, current));
+ const currentAnswerAgrees = confirmedCurrent.length > 0 && !currentRecords.some(record => record.answerStatus === 'conflict') &&
+ confirmedCurrent.every(mapping => mapping.status === 'matched') &&
+ new Set(confirmedCurrent.map(mapping => JSON.stringify([...mapping.labels].sort()))).size === 1;
const searchName = scopeName(searchScope);
shadow.getElementById('qb-query-state').textContent = query.trim() ? `${searchName} · ${pool.length} 题 · 显示 ${matches.length} 个结果${matches.length === 50 ? '（最多50条，请细化关键词）' : ''}` : `${searchName} · 可输入题干、选项或标准答案关键词`;
if (!matches.length) {
@@ -2462,24 +2622,25 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
resultBox.append(empty);
return;
}
- const current = currentQuestion();
matches.forEach(({ record, match, matchedField }) => {
const card = node('article', 'result');
const meta = node('div', 'meta');
const statusText = record.answerStatus === 'confirmed' ? '已确认' : record.answerStatus === 'conflict' ? '答案冲突' : '待补答案';
const matchLabel = matchedField === 'options' ? '选项匹配' : matchedField === 'answer' ? '答案匹配' : ({ exact: '题干一致', partial: '文字匹配', similar: '相似候选' })[match] || '候选';
- meta.append(node('span', `badge ${record.answerStatus}`, statusText), node('span', '', `${({ single: '单选', multiple: '多选', judge: '判断' })[record.type] || '题目'} · ${matchLabel}`));
+ const currentMatches = matchesCurrentQuestion(record, current);
+ const mapped = currentMatches && record.answerStatus === 'confirmed' ? QBCore.mapAnswers(record, current) : null;
+ const verifiedCurrent = currentMatches && currentAnswerAgrees && mapped?.status === 'matched';
+ meta.append(node('span', `badge ${record.answerStatus}`, statusText), node('span', '', `${({ single: '单选', multiple: '多选', judge: '判断' })[record.type] || '题目'} · ${currentMatches ? '当前题完整匹配' : matchLabel}`));
card.append(meta, node('p', 'stem', record.stem));
const answer = node('div', `answer ${record.answerStatus !== 'confirmed' ? 'pending' : ''}`);
- answer.append(node('span', 'answer-label', '正确答案'));
+ answer.append(node('span', 'answer-label', verifiedCurrent ? '本题正确答案' : record.answerStatus === 'missing' ? '标准答案' : '候选题答案'));
if (record.answerStatus === 'confirmed') {
const texts = record.answerTexts || [];
answer.append(node('strong', '', texts.length ? texts.join('；') : '标准答案缺少文字，需核验选项'));
- const mapped = current ? QBCore.mapAnswers(record, current) : null;
- if (mapped?.status === 'matched' && mapped.labels?.length) answer.append(node('span', 'mapping', `当前页面对应：${mapped.labels.join('、')}`));
- else answer.append(node('span', 'mapping', '当前页面选项未确认，请按答案内容核对。'));
+ if (verifiedCurrent && mapped.labels?.length) answer.append(node('span', 'mapping', `当前页面对应：${mapped.labels.join('、')}`));
+ else answer.append(node('span', 'mapping', currentMatches ? '答案尚不能唯一对应当前题，请核对题干和来源。' : current ? '与当前题的题干或完整选项不同，请核对题干。' : '尚未识别当前完整题目，请核对题干。'));
} else {
- answer.append(node('strong', '', record.answerStatus === 'conflict' ? '存在不同标准答案，需要核验' : '尚未取得标准答案'));
+ answer.append(node('strong', '', record.answerStatus === 'conflict' ? '存在不同标准答案，需要核验' : record.type === 'judge' ? '标准答案未确认' : '尚未取得标准答案'));
if (record.answerStatus === 'conflict' && record.conflicts?.length) answer.append(node('span', 'mapping', '冲突记录已保留在 JSON / CSV 备份中。'));
}
card.append(answer);
@@ -2551,6 +2712,12 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
download(JSON.stringify(backup, null, 2), exportFilename('内容补全前原始备份', backup.records.length, 'json'), 'application/json;charset=utf-8');
tell(`已导出内容补全前的 ${backup.records.length} 条原始记录。`);
}
+ function exportJudgeEvidenceBackup() {
+ const backup = storage.get(JUDGE_EVIDENCE_BACKUP_KEY, null);
+ if (!backup || backup.schemaVersion !== 1 || !Array.isArray(backup.records)) return tell('没有判断题答案核验前的备份。');
+ download(JSON.stringify(backup, null, 2), exportFilename('判断题答案核验前原始备份', backup.records.length, 'json'), 'application/json;charset=utf-8');
+ tell(`已导出判断题答案核验前的 ${backup.records.length} 条原始记录。`);
+ }
async function parseImportFile(file) {
if (file.size > 20 * 1024 * 1024) throw new Error('文件超过 20 MB，请拆分后导入');
const text = (await file.text()).replace(/^\uFEFF/, '');
@@ -2583,10 +2750,10 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
if (incoming.length > 50000) throw new Error('本次导入超过 50000 条记录，请分批导入');
}
const before = records.length;
- const expanded = QBCore.upsert(records, repairAnswerConflicts(removeBackedUpImagePredecessors(incoming, records)).records);
+ const expanded = QBCore.upsert(records, repairAnswerConflicts(repairJudgeEvidence(removeBackedUpImagePredecessors(incoming, records)).records).records);
const compacted = QBCore.compactRecords(expanded);
if (compacted.removed > 0) ensureCleanupBackup(expanded);
- const merged = repairAnswerConflicts(compacted.records).records;
+ const merged = repairAnswerConflicts(repairJudgeEvidence(compacted.records).records).records;
records = merged;
recordsDirty = true;
persistRecords();
@@ -2641,6 +2808,7 @@ if (typeof module !== 'undefined' && module.exports) module.exports = QBAuto;
重复记录整理
重复加载的题目按批次对应合并，保留原题库中的同文题和全部来源 ID。首次整理前会保留原始备份。
答案误报恢复
只恢复旧版因多个正确选项文字相同产生、且全部冲突证据一致的误报。修复前记录独立备份，真实答案冲突继续保留。
旧题内容补全
新完整题库批次与页面题数一致、位置和文字答案均能唯一核对时，补全旧版遗漏的图片、乘号或正负号实体，并保留原始题目 ID 与独立备份。
判断题答案核验
缺少网页标准答案依据的旧判断题改为待补；重新取得标准答案后补全，核验前原值单独保留。
重复记录整理
重复加载的题目按批次对应合并，保留原题库中的同文题和全部来源 ID。首次整理前会保留原始备份。
答案误报恢复
只恢复旧版因多个正确选项文字相同产生、且全部冲突证据一致的误报。修复前记录独立备份，真实答案冲突继续保留。
旧题内容补全
新完整题库批次与页面题数一致、位置和文字答案均能唯一核对时，补全旧版遗漏的图片、乘号或正负号实体，并保留原始题目 ID 与独立备份。
判断题答案核验
缺少网页标准答案依据的旧判断题改为待补；重新取得标准答案后补全，核验前原值单独保留。