daily-question 2.1.0 → 2.1.1

package/lib/bank.js

@@ -1,4 +1,4 @@
-import { CHOICE_TYPES, QUESTION_TYPE_LABEL } from './subjects.js'
+import { CHOICE_TYPES, QUESTION_TYPE_LABEL, hasChoiceOptions, validChoiceKey } from './subjects.js'
 import { extractPdfTextAsync } from './pdf.js'
 
 /**
@@ -9,13 +9,15 @@ import { extractPdfTextAsync } from './pdf.js'
  */
 
 const OPTION_LINE = /^\s*(?:[（(]\s*([A-H])\s*[)）]|([A-H])\s*[.、．:：)）])\s*(.+)$/
-const QUESTION_START = /^\s*(?:#{1,6}\s*)?(?:第\s*)?(\d{1,4})\s*(?:题|[.、．)）])\s*(.*)$/
+const QUESTION_START = /^\s*((?:#{1,6}\s*)?(?:第\s*)?)(\d{1,4})\s*(题|[.、．)）])\s*(.*)$/
 const LABEL_LINE = /^\s*(?:【?\s*(答案|参考答案|正确答案|解析|详解|答案详解|【解析】|分析|知识点|考点|难度|题型|答|解)\s*】?\s*[:：]\s*)(.*)$/
 const HARD_SEPARATOR = /^\s*(?:-{3,}|\*{3,}|={3,})\s*$/
 const BRACKET_MARK = /^\s*【\s*(题目|题干|问题)\s*】\s*(.*)$/
 const TYPE_WORDS = [
-  ['single', ['单项选择', '单选', '选择题']],
+  ['cloze', ['完形填空', '英语知识运用']],
+  ['reading', ['阅读理解']],
   ['multiple', ['多项选择', '多选']],
+  ['single', ['单项选择', '单选', '选择题']],
   ['fill', ['填空']],
   ['solution', ['解答', '计算', '证明', '综合应用', '算法设计', '综合题']],
   ['analysis', ['分析题', '材料分析']],
@@ -24,6 +26,12 @@ const TYPE_WORDS = [
   ['shortanswer', ['简答']],
 ]
 
+function answerSection(name) {
+  if (/解析|详解|^(分析|解)$/.test(name)) return 'explanation'
+  if (/答案|^答$/.test(name)) return 'answer'
+  return null
+}
+
 /** 判断一行是否处于 ``` 代码围栏内，用于避免在代码块里切分题目。 */
 function fenceTracker() {
   let inside = false
@@ -41,29 +49,42 @@ function splitBlocks(text) {
   const isFenced = fenceTracker()
   const blocks = []
   let current = []
+  let inAnswer = false
+  let questionNumber = null
+  let blankBefore = false
   const push = () => {
     const body = current.join('\n').trim()
     if (body) blocks.push(body)
     current = []
+    inAnswer = false
+    questionNumber = null
   }
   for (const line of lines) {
     const fenced = isFenced(line)
-    if (!fenced && (HARD_SEPARATOR.test(line) || BRACKET_MARK.test(line) || (QUESTION_START.test(line) && current.join('\n').trim()))) {
-      if (BRACKET_MARK.test(line)) {
-        push()
-        const rest = BRACKET_MARK.exec(line)[2]
-        current = [rest].filter(Boolean)
-        continue
-      }
-      if (HARD_SEPARATOR.test(line)) {
-        push()
-        continue
-      }
+    const bracket = fenced ? null : BRACKET_MARK.exec(line)
+    if (bracket || (!fenced && HARD_SEPARATOR.test(line))) {
       push()
-      current = [line]
+      if (bracket?.[2]) current.push(bracket[2])
+      blankBefore = false
       continue
     }
+    const numbered = fenced ? null : QUESTION_START.exec(line)
+    if (numbered) {
+      const [, prefix, digits, suffix, stem] = numbered
+      const number = Number(digits)
+      const explicit = prefix || suffix === '题'
+      // shortcut: 裸数字题号与解析步骤有歧义，低置信度时请用“第 N 题”或分隔线。
+      const nextQuestion = blankBefore && number === questionNumber + 1
+        && (/^(?:已知|设|下列|试问|证明[:：]|计算[:：])/.test(stem) || /[?？]$/.test(stem))
+      if (explicit || !inAnswer || nextQuestion) {
+        push()
+        questionNumber = number
+      }
+    }
+    const label = fenced ? null : LABEL_LINE.exec(line)
+    if (label && answerSection(label[1].replace(/[【】]/g, ''))) inAnswer = true
     current.push(line)
+    blankBefore = !line.trim()
   }
   push()
   return blocks
@@ -121,14 +142,10 @@ export function parseBlock(block, index) {
     if (label) {
       const name = label[1].replace(/[【】]/g, '')
       const rest = label[2].trim()
-      if (name.includes('答案') || name === '答') {
-        section = 'answer'
-        if (rest) sections.answer.push(entry)
-        continue
-      }
-      if (name.includes('解析') || name.includes('详解') || name === '分析' || name === '解') {
-        section = 'explanation'
-        if (rest) sections.explanation.push(entry)
+      const contentSection = answerSection(name)
+      if (contentSection) {
+        section = contentSection
+        if (rest) sections[section].push({ ...entry, text: rest })
         continue
       }
       if (name === '知识点' || name === '考点') {
@@ -153,9 +170,9 @@ export function parseBlock(block, index) {
     sections[section].push(entry)
   }
 
-  const stemEntries = sections.stem.map((entry) => ({
+  const stemEntries = sections.stem.map((entry, index) => ({
     ...entry,
-    text: QUESTION_START.test(entry.text) && !entry.fenced ? entry.text.replace(QUESTION_START, '$2').trim() : entry.text,
+    text: index === 0 && !entry.fenced ? entry.text.replace(QUESTION_START, '$4').trim() : entry.text,
   }))
   const optionLines = stemEntries.filter((entry) => !entry.fenced && OPTION_LINE.test(entry.text))
   const stemBody = stemEntries.filter((entry) => entry.fenced || !OPTION_LINE.test(entry.text))
@@ -184,21 +201,16 @@ export function parseBlock(block, index) {
   const issues = []
   if (!stemBody) issues.push('未识别到题干')
   else if (stemBody.length < 6) issues.push('题干过短，可能识别不完整')
-  if (CHOICE_TYPES.has(type) && options.length < 2) issues.push('选择题未识别到选项')
+  if (CHOICE_TYPES.has(type) && !hasChoiceOptions(options)) issues.push('选择题需要至少两个不同且有效的选项')
   if (!answerRaw) issues.push('没有参考答案（标记为缺少参考答案）')
   if (!explanation) issues.push('没有解析（可稍后补充）')
   if (optionLines.length && !options.length) issues.push('选项行格式无法识别')
 
   let answerKey = ''
   const answerLetters = CHOICE_TYPES.has(type) ? lettersOf(answerRaw) : ''
-  if (CHOICE_TYPES.has(type)) {
-    if (answerLetters && options.every((option) => option.key !== answerLetters[0])) {
-      issues.push('参考答案的选项字母不在选项列表中')
-    } else if (type === 'single' && answerLetters.length > 1) {
-      issues.push('参考答案给出多个选项，题型可能应为多项选择题')
-    } else if (answerLetters) {
-      answerKey = answerLetters
-    }
+  if (answerLetters) {
+    if (validChoiceKey(type, answerLetters, options)) answerKey = [...answerLetters].sort().join('')
+    else issues.push('参考答案与题型或选项不匹配，将由用户自行判定')
   }
 
   return {
@@ -219,6 +231,11 @@ export function parseBlock(block, index) {
   }
 }
 
+export function isUsableBankItem(item) {
+  return typeof item.stem === 'string' && item.stem.trim().length >= 6
+    && (!CHOICE_TYPES.has(item.type) || hasChoiceOptions(item.options))
+}
+
 /** 像标题、说明或分隔块的片段：不含选项/答案/解析，且不像一道题。 */
 function isHeaderBlock(item) {
   if (item.options.length || item.answer || item.explanation || item.knowledge.length) return false
@@ -259,8 +276,8 @@ export function parseBankText(text, { filename = '' } = {}) {
   if (items.length === 1) {
     warnings.push('只识别到 1 道题：如果这是多题题库，请用“题号 / --- / 【题目】”等分隔符分开每道题')
   }
-  const usable = items.filter((item) => item.stem && item.options.length + item.answer.length > 0).length
-  if (!usable) warnings.push('没有可用题目：题干、选项与答案都没有被正确识别')
+  const usable = items.filter(isUsableBankItem).length
+  if (!usable) warnings.push('没有可用题目：请检查题干及选择题选项是否完整')
   if (filename) warnings.push(`来源文件：${filename}`)
   return { items, warnings, usable }
 }

package/lib/exam-dates.js

@@ -1,3 +1,5 @@
+import { abortable } from './async.js'
+
 /**
  * 考研日期的权威性处理。
  *
@@ -269,93 +271,125 @@ export function computeCountdown(year, examInfo, today = todayISO()) {
 }
 
 function stripHtml(html) {
-  return String(html || '')
-    .replace(/<script[\s\S]*?<\/script>/gi, ' ')
-    .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+  return html
+    .replace(/<!--[\s\S]*?-->/g, ' ')
+    .replace(/<(head|title|script|style|nav|aside|footer|a)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, ' ')
+    .replace(/\r?\n/g, ' ')
+    .replace(/<\/(?:p|div|li|tr|h[1-6])\s*>|<br\b[^>]*>/gi, '\n')
     .replace(/<[^>]+>/g, ' ')
-    .replace(/&nbsp;/g, ' ')
+    .replace(/&(?:nbsp|#160|#xa0);/gi, ' ')
     .replace(/&amp;/g, '&')
     .replace(/&lt;/g, '<')
     .replace(/&gt;/g, '>')
-    .replace(/\s+/g, ' ')
 }
 
-function isOfficialHost(url) {
+function officialUrl(value) {
   try {
-    const host = new URL(url).hostname.toLowerCase()
-    return OFFICIAL_HOSTS.some((suffix) => host === suffix || host.endsWith(`.${suffix}`))
+    const url = new URL(value)
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) return null
+    if (!OFFICIAL_HOSTS.some((host) => url.hostname === host || url.hostname.endsWith('.' + host))) return null
+    url.hash = ''
+    return url.href
   } catch {
-    return false
+    return null
   }
 }
 
-/**
- * 联网核验某年的考试日期。
- *
- * 只在教育部 / 教育考试院 / 研招网域名命中“初试时间为 YYYY 年 12 月 D 日”时
- * 才认定为官方公布；否则如实返回未核实，不做任何猜测。
- */
+function examSessions(text) {
+  return Array.from(text.matchAll(/(\d{4})年?(?:(?:全国)?硕士研究生招生|考研|研考)/g), (match) => Number(match[1]))
+}
+
+function readExamDates(body, year) {
+  if (typeof body?.content !== 'string' || !['html', 'text'].includes(body.kind)) return null
+  const html = body.kind === 'html'
+  const title = html ? stripHtml(/<title\b[^>]*>([\s\S]*?)<\/title\s*>/i.exec(body.content)?.[1] || '').trim() : ''
+  const heading = html ? stripHtml(/<h([12])\b[^>]*>([\s\S]*?)<\/h\1\s*>/i.exec(body.content)?.[2] || '') : ''
+  const paragraphs = html ? stripHtml(body.content.replace(/<h([1-6])\b[^>]*>[\s\S]*?<\/h\1\s*>/gi, '<br>')) : body.content
+  const text = paragraphs.normalize('NFKC').replace(/[^\S\r\n]+/g, '')
+  const titleYears = examSessions(title.normalize('NFKC').replace(/\s+/g, ''))
+  const pageYears = titleYears.length ? titleYears : examSessions(heading.normalize('NFKC').replace(/\s+/g, '') + '\n' + text)
+  if (!pageYears.includes(year)) return null
+
+  const examYear = year - 1
+  const pattern = new RegExp(`初试时间(?:为|是|定于|安排在|调整为)?:?${examYear}年12月(\\d{1,2})日?(?:至|到|[-–—~])(?:(?:${examYear}年)?12月)?(\\d{1,2})日`, 'g')
+  let result = null
+  for (const sentence of text.split(/[\r\n。；;，,]+/)) {
+    const years = examSessions(sentence)
+    if (years.length && !years.includes(year)) continue
+    for (const match of sentence.matchAll(pattern)) {
+      const start = Number(match[1])
+      const end = Number(match[2])
+      if (start < 1 || end < start || end > 31) continue
+      const date = `${examYear}-12-${pad2(start)}`
+      const endDate = `${examYear}-12-${pad2(end)}`
+      if (result && (result.date !== date || result.endDate !== endDate)) return null
+      result = { date, endDate, title, snippet: match[0] }
+    }
+  }
+  return result
+}
+
+/** 仅采信目标届次的官方正文明确给出的完整初试区间。 */
 export async function verifyExamDateOnline({ year, web, signal, fetchLimit = 3 }) {
   const checked = []
-  const now = new Date().toISOString()
-  if (!web || typeof web.search !== 'function') {
+  if (typeof web?.search !== 'function' || typeof web?.fetch !== 'function') {
     return { ok: false, reason: 'web 服务不可用，无法联网核验官方日期', checked }
   }
+  if (!Number.isInteger(year) || year < 1001 || year > 9999) return { ok: false, reason: '考研届次无效', checked }
   const expectYear = year - 1
-  let sources = []
-  try {
-    const result = await web.search({ query: `${year}年全国硕士研究生招生考试 初试时间 12月`, maxResults: 8 }, signal)
-    sources = Array.isArray(result?.sources) ? result.sources : []
-  } catch (error) {
-    return { ok: false, reason: `联网检索失败：${error?.message || error}`, checked }
-  }
-
-  const official = sources.filter((item) => item && item.url && isOfficialHost(item.url)).slice(0, fetchLimit)
-  if (!official.length) {
-    return {
-      ok: false,
-      reason: `没有检索到 ${year} 考研在官方渠道（moe.gov.cn / chsi.com.cn / neea.edu.cn）发布的初试日期，保持“尚未核实/估算”状态`,
-      checked: sources.map((item) => item.url).slice(0, 8),
-    }
-  }
-
-  for (const source of official) {
-    checked.push(source.url)
+  const visited = new Set()
+  let searched = false
+  let searchError
+  for (const host of OFFICIAL_HOSTS) {
+    if (signal?.aborted) break
+    const subject = host === 'moe.gov.cn' ? '招生工作管理规定' : '招生考试'
+    const query = `site:${host} ${year}年全国硕士研究生${subject} 初试时间 ${expectYear}年12月`
+    let sources
     try {
-      const page = await web.fetch({ url: source.url }, signal)
-      const text = page?.body?.kind === 'html' ? stripHtml(page.body.content) : String(page?.body?.content || '')
-      const match = new RegExp(`初试时间[^。；]{0,40}?${expectYear}年12月(\\d{1,2})日`).exec(text)
-        || new RegExp(`${expectYear}年12月(\\d{1,2})日至`).exec(text)
-      if (!match) continue
-      const day = Number(match[1])
-      if (!(day >= 1 && day <= 31)) continue
-      const date = `${expectYear}-12-${pad2(day)}`
-      return {
-        ok: true,
-        record: {
-          date,
-          endDate: addDays(date, 1),
-          status: 'official',
-          source: source.title || source.url,
-          sourceUrl: source.url,
-          publishedAt: source.publishedAt || '',
-          verifiedAt: now,
-          method: 'online-search',
-          note: `由官方渠道页面核验：${source.url}`,
-        },
-        checked,
-        snippet: match[0],
-      }
+      const result = await abortable(() => web.search({ query, maxResults: 8 }, signal), signal)
+      searched = true
+      sources = Array.isArray(result?.sources) ? result.sources : []
     } catch (error) {
-      checked.push(`${source.url} (${error?.message || error})`)
+      searchError = error
+      continue
+    }
+    let fetched = 0
+    for (const source of sources) {
+      if (signal?.aborted || fetched >= fetchLimit) break
+      const url = officialUrl(source?.url)
+      if (!url || visited.has(url)) continue
+      visited.add(url)
+      fetched++
+      try {
+        const page = await abortable(() => web.fetch({ url }, signal), signal)
+        const finalUrl = officialUrl(page?.url || url)
+        const found = finalUrl && readExamDates(page?.body, year)
+        checked.push(url)
+        if (!found) continue
+        return {
+          ok: true,
+          record: {
+            date: found.date,
+            endDate: found.endDate,
+            status: 'official',
+            source: found.title || source.title || finalUrl,
+            sourceUrl: finalUrl,
+            publishedAt: source.publishedAt || '',
+            verifiedAt: new Date().toISOString(),
+            method: 'online-search',
+            note: `由官方渠道页面核验：${finalUrl}`,
+          },
+          checked,
+          snippet: found.snippet,
+        }
+      } catch (error) {
+        checked.push(`${url} (${error?.message || error})`)
+      }
     }
   }
-
-  return {
-    ok: false,
-    reason: `检索到官方渠道页面，但未能在其中确认 ${expectYear}年12月的初试日期`,
-    checked,
-  }
+  if (signal?.aborted) return { ok: false, reason: '联网核验已超时或取消', checked }
+  if (!searched) return { ok: false, reason: `联网检索失败：${searchError?.message || searchError}`, checked }
+  return { ok: false, reason: `未能从官方正文确认 ${year} 考研（${expectYear}年12月）的初试起止日期`, checked }
 }
 
 export function addDays(iso, days) {

package/lib/generate.js

@@ -1,4 +1,4 @@
-import { describeSubjectForPrompt, QUESTION_TYPE_LABEL, CHOICE_TYPES } from './subjects.js'
+import { describeSubjectForPrompt, QUESTION_TYPE_LABEL, CHOICE_TYPES, hasChoiceOptions, validChoiceKey } from './subjects.js'
 import { asString, asStringArray, generateText, parseJsonLoose, resolveModel } from './llm-json.js'
 import { loadExamReferences, reviewExamFit } from './references.js'
 import { generationPlan,findQuestionRepeat } from './generation-history.js'
@@ -34,7 +34,7 @@ const WRITER_SYSTEM = `你是一位中国大陆硕士研究生招生考试的命
 
 const SOLVER_SYSTEM = `你是一位独立解题专家。请求中只有题干和选项，不提供命题答案或解析。
 请独立求解，检查题干条件、可解性和唯一性；不要猜测命题人的答案。
-选择题在 answerKey 中写正确选项字母，多选去重并升序；其他题型留空。
+单选、完形和阅读在 answerKey 中只写一个正确选项字母；多选去重并升序；非选择题留空。
 只输出 JSON：{"solvable":true,"answer":"最终答案","answerKey":"","explanation":"完整推导、依据及易错点，不少于20字","issues":[]}。
 无法确定时 solvable 为 false，并在 issues 中说明原因。`
 
@@ -170,7 +170,7 @@ async function writeQuestion({ ctx, subject, examInfo, allowed, allowedLabels, t
     '  "stem": "题干（Markdown + LaTeX）",',
     '  "options": [{"key": "A", "text": "选项内容（Markdown + LaTeX）"}],   // 选择题必填，其他题型为空数组',
     '  "answer": "标准答案（Markdown）。选择题为正确选项字母，例如 B；填空题为最终结果；解答题给出最终结论",',
-    '  "answerKey": "单选题的正确选项字母；多选题为按字母升序拼接的字符串，例如 \\"ABD\\"；其他题型为空字符串",',
+    '  "answerKey": "单选、完形、阅读只填一个正确选项字母；多选按字母升序拼接，例如 ABD；非选择题留空",',
     '  "explanation": "完整解析（Markdown + LaTeX），必须含关键思路、推导步骤、核心知识点与易错点",',
     '  "knowledge": ["知识点标签", "..."],',
     '  "syllabusCheck": "一句话说明本题对应大纲的哪一部分"',
@@ -337,17 +337,14 @@ export function structuralProblems(candidate, allowedTypes) {
   if (!candidate.explanation || candidate.explanation.length < 20) problems.push('解析缺失或过短（缺少必要推导）')
   if (!allowedTypes.includes(candidate.type)) problems.push(`题型 ${candidate.type} 不在本科目允许范围内`)
   if (CHOICE_TYPES.has(candidate.type)) {
-    if (candidate.options.length < 2) problems.push('选择题至少需要 2 个选项')
-    const keys = candidate.options.map((option) => option.key)
-    if (new Set(keys).size !== keys.length) problems.push('选项字母重复')
-    if (candidate.type === 'single') {
-      if (candidate.answerKey.length !== 1) problems.push('单项选择题必须有且仅有一个正确选项')
-      else if (!keys.includes(candidate.answerKey)) problems.push('正确选项不在选项列表中')
-    } else if (!candidate.answerKey) {
-      problems.push('多项选择题必须写明正确选项集合')
+    if (!hasChoiceOptions(candidate.options)) problems.push('选择题至少需要两个有效选项，选项字母须为 A–H 且不可重复')
+    if (!validChoiceKey(candidate.type, candidate.answerKey, candidate.options)) {
+      problems.push(candidate.type === 'multiple'
+        ? '多项选择题必须写明正确选项集合，字母不可重复且必须属于本题选项'
+        : '单选、完形和阅读必须有且仅有一个有效的正确选项')
+    } else if ([...candidate.answerKey].sort().join('') !== candidate.answerKey) {
+      problems.push('多选题正确选项必须按字母升序排列')
     }
-    const sorted = candidate.answerKey.split('').sort()
-    if (sorted.join('') !== candidate.answerKey) problems.push('多选题正确选项必须按字母升序排列')
   }
   return problems
 }
@@ -401,7 +398,7 @@ export async function reviseAnswer({ ctx, subject, examInfo, question, currentAn
       '输出字段（严格 JSON）：',
       '{',
       '  "answer": "标准答案（Markdown）",',
-      '  "answerKey": "选择题的正确选项字母（多选按字母升序），非选择题为空字符串",',
+      '  "answerKey": "单选、完形、阅读只填一个正确选项字母；多选按字母升序；非选择题留空",',
       '  "explanation": "完整解析（Markdown + LaTeX）"',
       '}',
     ].filter(Boolean).join('\n')

package/lib/routes.js

@@ -12,51 +12,36 @@ const MAX_BODY_BYTES = 60 * 1024 * 1024
 const MATHJAX_FILE = fileURLToPath(new URL('../vendor/mathjax/tex-svg.js', import.meta.url))
 let mathjaxBytes = null
 
-/** 最小 CSRF 防护：带 Origin 的请求必须与 Host 同源。 */
-function trusted(req) {
-  const origin = req.headers.origin
-  if (origin === undefined) return true
-  try {
-    return new URL(origin).host === req.headers.host
-  } catch {
-    return false
-  }
-}
-
-function sendJson(res, status, body) {
-  const payload = JSON.stringify(body)
-  res.writeHead(status, {
-    'content-type': 'application/json; charset=utf-8',
-    'cache-control': 'no-store',
-  })
-  res.end(payload)
+function json(status, body) {
+  return Response.json(body, { status, headers: { 'cache-control': 'no-store' } })
 }
 
-function readBody(req) {
-  return new Promise((resolve, reject) => {
-    const chunks = []
-    let size = 0
-    req.on('data', (chunk) => {
-      size += chunk.length
-      if (size > MAX_BODY_BYTES) {
-        reject(new Error('请求体过大'))
-        req.destroy()
-        return
-      }
-      chunks.push(chunk)
-    })
-    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
-    req.on('error', reject)
-  })
+async function readBody(request) {
+  if (Number(request.headers.get('content-length')) > MAX_BODY_BYTES) return null
+  if (!request.body) return ''
+  const reader = request.body.getReader()
+  const chunks = []
+  let size = 0
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) return Buffer.concat(chunks, size).toString('utf8')
+      size += value.byteLength
+      if (size > MAX_BODY_BYTES) return null
+      chunks.push(value)
+    }
+  } finally {
+    reader.releaseLock()
+  }
 }
 
 /**
  * 注册路由。
- * @param {{register: Function}} webServer ctx.webServer
+ * @param {{fetch: {register: Function}}} connection ctx.connection
  * @param {import('./service.js').DailyQuestionService} service
- * @returns {() => void} 注销函数
+ * @returns {() => Promise<void>} 注销函数
  */
-export function registerRoutes(webServer, service, logger = console) {
+export function registerRoutes(connection, service, logger = console) {
   const ops = {
     bootstrap: () => service.bootstrap(),
     checkUpdates: (args) => service.checkUpdates(args),
@@ -87,39 +72,31 @@ export function registerRoutes(webServer, service, logger = console) {
     },
   }
 
-  const disposeRpc = webServer.register({
-    kind: 'exact',
+  const disposeRpc = connection.fetch.register({
     path: RPC_PATH,
-    handler: async (req, res) => {
-      if (!trusted(req)) {
-        sendJson(res, 403, { ok: false, error: { message: 'forbidden', code: 'FORBIDDEN' } })
-        return
-      }
-      if (req.method !== 'POST') {
-        sendJson(res, 405, { ok: false, error: { message: '只接受 POST', code: 'METHOD' } })
-        return
-      }
+    methods: ['POST'],
+    requestBody: 'streaming',
+    fetch: async (request) => {
       let payload
       try {
-        payload = JSON.parse(await readBody(req))
+        const body = await readBody(request)
+        if (body === null) return json(413, { ok: false, error: { message: '请求体过大', code: 'BODY_TOO_LARGE' } })
+        payload = JSON.parse(body)
       } catch (error) {
-        sendJson(res, 400, { ok: false, error: { message: `请求体解析失败：${error.message}`, code: 'BAD_BODY' } })
-        return
+        return json(400, { ok: false, error: { message: `请求体解析失败：${error.message}`, code: 'BAD_BODY' } })
       }
       const op = typeof payload?.op === 'string' ? payload.op : ''
-      const handler = ops[op]
-      if (!handler) {
-        sendJson(res, 400, { ok: false, error: { message: `未知操作：${op}`, code: 'UNKNOWN_OP' } })
-        return
+      if (!Object.hasOwn(ops, op)) {
+        return json(400, { ok: false, error: { message: `未知操作：${op}`, code: 'UNKNOWN_OP' } })
       }
       const started = Date.now()
       try {
-        const result = await handler(payload.args || {})
-        sendJson(res, 200, { ok: true, result })
+        const result = await ops[op](payload.args || {})
+        return json(200, { ok: true, result })
       } catch (error) {
         const message = error?.message || String(error)
         logger.warn?.(`daily-question: ${op} 失败（${Date.now() - started}ms）：${message}`)
-        sendJson(res, 500, {
+        return json(error?.code === 'ATTEMPT_CONFLICT' ? 409 : 500, {
           ok: false,
           error: {
             message,
@@ -131,49 +108,35 @@ export function registerRoutes(webServer, service, logger = console) {
     },
   })
 
-  const disposePing = webServer.register({
-    kind: 'exact',
+  const disposePing = connection.fetch.register({
     path: PING_PATH,
-    handler: (req, res) => {
-      if (!trusted(req)) {
-        sendJson(res, 403, { ok: false })
-        return
-      }
-      sendJson(res, 200, { ok: true, plugin: 'daily-question', version: 1 })
-    },
+    methods: ['GET'],
+    requestBody: 'buffered',
+    fetch: async () => json(200, { ok: true, plugin: 'daily-question', version: 1 }),
   })
 
   // 公式引擎：MathJax 3 的单文件 bundle（SVG 输出，自带字形路径，不需要字体文件）。
-  const disposeVendor = webServer.register({
-    kind: 'exact',
+  const disposeVendor = connection.fetch.register({
     path: MATHJAX_PATH,
-    handler: async (req, res) => {
-      if (req.method !== 'GET' && req.method !== 'HEAD') {
-        res.writeHead(405, { allow: 'GET, HEAD' })
-        res.end()
-        return
-      }
+    methods: ['GET', 'HEAD'],
+    requestBody: 'buffered',
+    fetch: async (request) => {
       try {
         if (!mathjaxBytes) mathjaxBytes = await readFile(MATHJAX_FILE)
-        res.writeHead(200, {
+        return new Response(request.method === 'HEAD' ? null : mathjaxBytes, { headers: {
           'content-type': 'text/javascript; charset=utf-8',
           'content-length': String(mathjaxBytes.length),
-          'cache-control': 'public, max-age=31536000, immutable',
-        })
-        if (req.method === 'HEAD') res.end()
-        else res.end(mathjaxBytes)
+          'cache-control': 'private, max-age=31536000, immutable',
+        } })
       } catch (error) {
         logger.warn?.(`daily-question: 公式引擎不可用（${error.message}）`)
-        res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' })
-        res.end('MathJax not bundled')
+        return new Response(request.method === 'HEAD' ? null : 'MathJax not bundled', { status: 404 })
       }
     },
   })
 
   logger.info?.(`daily-question: 接口已就绪 ${RPC_PATH}`)
-  return () => {
-    disposeRpc()
-    disposePing()
-    disposeVendor()
+  return async () => {
+    await Promise.all([disposeRpc(), disposePing(), disposeVendor()])
   }
 }