@lincyaw/addon-classroom 0.0.0-stage → 1.0.0-rc.1

package/src/domain/messages.ts

@@ -0,0 +1,298 @@
+import type { Locale } from '@lincyaw/kernel'
+
+interface Typical {
+  kind: string
+  hint: string
+}
+
+const zh = {
+  interaction: '课堂互动',
+  close: '关闭',
+  toolbar: {
+    button: '互动',
+    title: '课堂互动：提问、理解度、测验、预测与练习',
+    unanswered: (n: number) => `${n} 个未回答的提问`,
+  },
+  place: (index: number, title: string, block?: string) => `第 ${index} 页 · ${title}${block ? ` · ${block}` : ''}`,
+  people: (n: number) => `${n} 人`,
+  list: '，',
+  colon: '：',
+  quiz: {
+    selfTest: '自测：选择后提交，立即看到对错',
+    right: '回答正确',
+    wrong: (letters: string) => `回答错误，正确答案是 ${letters}`,
+    answering: '作答中',
+    closed: '作答已关闭',
+    notOpen: '尚未开放作答',
+    ended: '课堂已结束',
+    yours: (right: boolean) => `，你的答案${right ? '正确' : '错误'}`,
+    lateMine: '；关闭后送达的作答未计入',
+    waiting: '等待主讲开放作答',
+    submitted: (letters: string) => `已提交 ${letters}，作答关闭前可以修改`,
+    open: '作答中：选择后提交',
+    submit: '提交',
+    openButton: '开放作答',
+    closeButton: '关闭作答',
+    tally: (respondents: number, right: number) => `已作答 ${respondents} 人，答对 ${right} 人`,
+    late: (n: number) => `关闭后送达的作答 ${n} 份，未计入`,
+    letters: '、',
+  },
+  exercise: {
+    passed: (passed: number, total: number) => `通过 ${passed}/${total}`,
+    failed: (failed: number, total: number) => `未通过 ${failed}/${total}`,
+    notRun: (kind: string) => `无法运行：${kind}`,
+    code: '练习代码',
+    checks: '校验用例',
+    checking: '正在校验…',
+    submit: '提交',
+    noExecutor: '此处无法运行代码',
+    error: (hint: string, type: string, message: string, line?: number) => `${hint}。${type}${message ? `: ${message}` : ''}${line ? `（第 ${line} 行）` : ''}`,
+    tally: (submitted: number, passed: number) => `已提交 ${submitted} 人，通过 ${passed} 人`,
+    ended: '课堂已结束：结果只在本机显示，不再提交',
+    common: (kinds: string) => `；常见错误：${kinds}`,
+    noResult: '校验程序没有给出结果',
+    unchecked: { kind: '无法校验', hint: '校验未完成，请查看错误信息' } as Typical,
+    unknown: '查看错误信息',
+    typical: {
+      SyntaxError: { kind: '语法错误', hint: '检查括号、冒号与引号是否成对' },
+      IndentationError: { kind: '缩进错误', hint: '同一代码块的缩进要一致' },
+      TabError: { kind: '缩进错误', hint: '不要混用空格与制表符' },
+      NameError: { kind: '名字未定义', hint: '检查拼写，变量与函数要先定义再使用' },
+      NotImplementedError: { kind: '尚未实现', hint: '把占位代码换成实现' },
+      AssertionError: { kind: '结果不对', hint: '对照校验用例检查返回值' },
+      TypeError: { kind: '类型不匹配', hint: '检查参数个数与值的类型，例如是否返回了 None' },
+      ZeroDivisionError: { kind: '除以零', hint: '先处理除数为零的情况，例如空列表' },
+      IndexError: { kind: '下标越界', hint: '检查下标范围与空序列' },
+      KeyError: { kind: '键不存在', hint: '先检查字典中是否有这个键' },
+      AttributeError: { kind: '属性不存在', hint: '检查对象的类型与属性名' },
+      ValueError: { kind: '取值不合法', hint: '检查输入值的范围与格式' },
+      RecursionError: { kind: '递归太深', hint: '检查递归的结束条件' },
+      Timeout: { kind: '运行超时', hint: '可能有死循环，检查循环的结束条件' },
+    } as Record<string, Typical>,
+  },
+  pulse: {
+    question: '这一页理解了吗？',
+    levels: ['懂了', '有点模糊', '没懂'],
+    joinFirst: '加入课堂后，可以在这里告诉主讲你的理解程度。',
+    distribution: '理解度分布',
+  },
+  predict: {
+    yours: '你的预测',
+    invalidTargets: (property: string) => `预测的 ${property} 中每个子内容块只能列出一次。`,
+    missingTarget: (property: string, target: string, block: string) => `预测的 ${property} 目标 ${target} 不是 ${block} 的直接子内容块。`,
+    placeholder: '写下你的预测',
+    save: '保存预测',
+    saved: (what: string) => `你的预测：${what}`,
+    hidden: '保存预测之后，这里显示答案。',
+    kept: '预测保存在这个浏览器中',
+    sent: '预测保存在这个浏览器中，并已交给主讲',
+  },
+  questions: {
+    question: '问题',
+    placeholder: '写下你的问题',
+    ask: '提问',
+    attachedTo: (where: string) => `问题将关联到 ${where}`,
+    joinFirst: '加入课堂后，可以在这里向主讲提问。',
+    ended: '课堂已结束，不再接受提问。',
+    here: '这里的提问',
+    mine: '我的提问',
+    answered: '（已回答）',
+    markAnswered: '标为已回答',
+    markUnanswered: '标为未回答',
+    ai: (provider: string) => `AI 回答（${provider}）`,
+    aiTitle: (provider: string) => `请 AI 回答这个问题（由 ${provider} 的模型生成，发给课堂之前由你确认）`,
+    aiAnswering: 'AI 正在回答…',
+    aiDraft: 'AI 的回答，发给课堂之前请确认：',
+    aiFailed: (message: string) => `无法获得 AI 的回答：${message}`,
+    aiSetup: '如需 AI 回答提问，请先在“提问”窗格中设置你自己的模型服务。',
+    send: '发送到课堂',
+    discard: '放弃',
+    reply: (provider: string) => `AI 回答（${provider}）：`,
+  },
+  panel: {
+    waiting: '主讲创建课堂后，这里按位置汇总提问、理解度、测验、预测与练习。',
+    questions: '提问',
+    unanswered: (n: number) => `提问（未回答 ${n}）`,
+    none: '还没有提问',
+    pulse: '理解度',
+    quizzes: '测验',
+    predictions: '预测',
+    predicted: (place: string, respondents: number) => `${place}：已预测 ${respondents} 人`,
+    exercises: '练习',
+    quiz: (place: string, open: boolean, respondents: number, right: number) => `${place}：${open ? '作答中' : '已关闭'}，已作答 ${respondents} 人，答对 ${right} 人`,
+    exercise: (place: string, tally: string) => `${place}：${tally}`,
+    levels: ' · ',
+  },
+  notes: {
+    button: '笔记',
+    label: (what: string) => `笔记：${what}`,
+    blockOf: (section: string, kind: string) => `${section} · ${kind}`,
+    kinds: { table: '表格', code: '代码' },
+    mine: '我的笔记',
+    remove: '删除',
+    removeLabel: (text: string) => `删除笔记：${text}`,
+    new: '新建笔记',
+    save: '保存笔记',
+    inClassroom: '保存在课堂与这个浏览器中，只有你能看到',
+    inBrowser: '保存在这个浏览器中，只有你能看到',
+  },
+  fallback: {
+    answer: '答案',
+    checks: '校验',
+    exercise: '练习',
+    predict: '预测',
+    write: '先写下你的预测。',
+    reveal: '写下预测后显示',
+    checkCell: '# 校验：先运行上面的单元格，再运行这个单元格；没有报错就是通过。',
+    questions: { label: '提问', text: '：加入课堂后，在网页或幻灯片中向主讲提问。' },
+    pulse: { label: '理解度投票', text: (question: string, levels: string[]) => `：${question}（${levels.join(' / ')}）` },
+  },
+}
+
+export type ClassroomMessages = typeof zh
+
+const en: ClassroomMessages = {
+  interaction: 'Classroom Interaction',
+  close: 'Close',
+  toolbar: {
+    button: 'Interaction',
+    title: 'Classroom interaction: questions, understanding, quizzes, predictions, and exercises',
+    unanswered: n => `${n} unanswered question${n === 1 ? '' : 's'}`,
+  },
+  place: (index, title, block) => `Page ${index} · ${title}${block ? ` · ${block}` : ''}`,
+  people: n => String(n),
+  list: ', ',
+  colon: ': ',
+  quiz: {
+    selfTest: 'Self-test: choose, then submit to see whether you are right',
+    right: 'Right',
+    wrong: letters => `Wrong; the right answer is ${letters}`,
+    answering: 'Answering',
+    closed: 'Answering closed',
+    notOpen: 'Not open for answers yet',
+    ended: 'The classroom has ended',
+    yours: right => `, your answer is ${right ? 'right' : 'wrong'}`,
+    lateMine: '; answers that arrived after closing were not counted',
+    waiting: 'Waiting for the presenter to open the quiz',
+    submitted: letters => `Submitted ${letters}; you can change it until answering closes`,
+    open: 'Answering: choose, then submit',
+    submit: 'Submit',
+    openButton: 'Open Answering',
+    closeButton: 'Close Answering',
+    tally: (respondents, right) => `${respondents} answered, ${right} right`,
+    late: n => `${n} answer${n === 1 ? '' : 's'} arrived after closing, not counted`,
+    letters: ', ',
+  },
+  exercise: {
+    passed: (passed, total) => `Passed ${passed}/${total}`,
+    failed: (failed, total) => `Failed ${failed}/${total}`,
+    notRun: kind => `Couldn’t run: ${kind}`,
+    code: 'Exercise code',
+    checks: 'Checks',
+    checking: 'Checking…',
+    submit: 'Submit',
+    noExecutor: 'Code can’t run here',
+    error: (hint, type, message, line) => `${hint}. ${type}${message ? `: ${message}` : ''}${line ? ` (line ${line})` : ''}`,
+    tally: (submitted, passed) => `${submitted} submitted, ${passed} passed`,
+    ended: 'The classroom has ended: the result shows here only and is not submitted',
+    common: kinds => `; common errors: ${kinds}`,
+    noResult: 'The checks gave no result',
+    unchecked: { kind: 'Not checked', hint: 'The checks didn’t finish; read the error message' },
+    unknown: 'Read the error message',
+    typical: {
+      SyntaxError: { kind: 'Syntax error', hint: 'Check that brackets, colons, and quotes are paired' },
+      IndentationError: { kind: 'Indentation error', hint: 'Indent a block consistently' },
+      TabError: { kind: 'Indentation error', hint: 'Do not mix spaces and tabs' },
+      NameError: { kind: 'Undefined name', hint: 'Check the spelling; define variables and functions before using them' },
+      NotImplementedError: { kind: 'Not implemented', hint: 'Replace the placeholder with an implementation' },
+      AssertionError: { kind: 'Wrong result', hint: 'Compare the return value with the checks' },
+      TypeError: { kind: 'Type mismatch', hint: 'Check the number of arguments and the types, e.g. a missing return' },
+      ZeroDivisionError: { kind: 'Division by zero', hint: 'Handle a zero divisor first, e.g. an empty list' },
+      IndexError: { kind: 'Index out of range', hint: 'Check the index range and empty sequences' },
+      KeyError: { kind: 'Missing key', hint: 'Check that the dictionary has the key first' },
+      AttributeError: { kind: 'Missing attribute', hint: 'Check the type of the object and the attribute name' },
+      ValueError: { kind: 'Invalid value', hint: 'Check the range and format of the input' },
+      RecursionError: { kind: 'Recursion too deep', hint: 'Check where the recursion ends' },
+      Timeout: { kind: 'Timed out', hint: 'There may be an endless loop; check where loops end' },
+    },
+  },
+  pulse: {
+    question: 'Did you follow this page?',
+    levels: ['Got it', 'A bit unclear', 'Lost'],
+    joinFirst: 'Join the classroom to tell the presenter how well you follow.',
+    distribution: 'Understanding',
+  },
+  predict: {
+    yours: 'Your prediction',
+    invalidTargets: property => `Prediction ${property} must list each child block only once.`,
+    missingTarget: (property, target, block) => `Prediction ${property} target ${target} is not a direct child block of ${block}.`,
+    placeholder: 'Write down your prediction',
+    save: 'Save Prediction',
+    saved: what => `Your prediction: ${what}`,
+    hidden: 'Once you save your prediction, the answer shows here.',
+    kept: 'Your prediction is saved in this browser',
+    sent: 'Your prediction is saved in this browser and sent to the presenter',
+  },
+  questions: {
+    question: 'Question',
+    placeholder: 'Write your question',
+    ask: 'Ask',
+    attachedTo: where => `The question goes to ${where}`,
+    joinFirst: 'Join the classroom to ask the presenter here.',
+    ended: 'The classroom has ended and takes no more questions.',
+    here: 'Questions Here',
+    mine: 'My Questions',
+    answered: ' (answered)',
+    markAnswered: 'Mark as Answered',
+    markUnanswered: 'Mark as Unanswered',
+    ai: provider => `AI answer (${provider})`,
+    aiTitle: provider => `Ask the AI to answer this question (a model of ${provider}; you confirm before the classroom gets it)`,
+    aiAnswering: 'The AI is answering…',
+    aiDraft: 'The AI’s answer, to confirm before the classroom gets it:',
+    aiFailed: message => `Couldn’t get the AI’s answer: ${message}`,
+    aiSetup: 'To have the AI answer questions, set up your own model service in the Ask pane first.',
+    send: 'Send to Classroom',
+    discard: 'Discard',
+    reply: provider => `AI answer (${provider}): `,
+  },
+  panel: {
+    waiting: 'Once the presenter creates a classroom, its questions, understanding, quizzes, predictions, and exercises are gathered here by place.',
+    questions: 'Questions',
+    unanswered: n => `Questions (${n} unanswered)`,
+    none: 'No questions yet',
+    pulse: 'Understanding',
+    quizzes: 'Quizzes',
+    predictions: 'Predictions',
+    predicted: (place, respondents) => `${place}: ${respondents} predicted`,
+    exercises: 'Exercises',
+    quiz: (place, open, respondents, right) => `${place}: ${open ? 'answering' : 'closed'}, ${respondents} answered, ${right} right`,
+    exercise: (place, tally) => `${place}: ${tally}`,
+    levels: ' · ',
+  },
+  notes: {
+    button: 'Notes',
+    label: what => `Notes: ${what}`,
+    blockOf: (section, kind) => `${section} · ${kind}`,
+    kinds: { table: 'table', code: 'code' },
+    mine: 'My Notes',
+    remove: 'Delete',
+    removeLabel: text => `Delete note: ${text}`,
+    new: 'New Note',
+    save: 'Save Note',
+    inClassroom: 'Saved in the classroom and in this browser; only you can see it',
+    inBrowser: 'Saved in this browser; only you can see it',
+  },
+  fallback: {
+    answer: 'Answer',
+    checks: 'Checks',
+    exercise: 'Exercise',
+    predict: 'Predict',
+    write: 'Write down your prediction first.',
+    reveal: 'Show After You Predict',
+    checkCell: '# Check: run the cell above, then this one; no error means it passes.',
+    questions: { label: 'Questions', text: ': join the classroom to ask the presenter on the web page or in the slides.' },
+    pulse: { label: 'Understanding vote', text: (question, levels) => `: ${question} (${levels.join(' / ')})` },
+  },
+}
+
+export const MESSAGES: Record<Locale, ClassroomMessages> = { 'zh-CN': zh, en }

package/src/domain/notes.ts

@@ -0,0 +1,12 @@
+export interface Note {
+  section: string
+  block?: string
+  text: string
+  at: number
+}
+
+export function notesAt<T extends { value: Note }>(notes: Iterable<T>, section: string, block?: string): T[] {
+  return [...notes]
+    .filter(({ value }) => value.section === section && value.block === block)
+    .sort((a, b) => a.value.at - b.value.at)
+}

package/src/domain/place.ts

@@ -0,0 +1,25 @@
+import type { SectionNumbers } from './config.ts'
+import type { ClassroomMessages } from './messages.ts'
+
+export interface Place {
+  section: string
+  block: string
+  title: string
+  index: number
+}
+
+export function placeKey(place: Pick<Place, 'section' | 'block'>): string {
+  return `${place.section}/${place.block}`
+}
+
+export function placeIndex(place: { section: string, index: number }, numbers: SectionNumbers = {}): number {
+  return numbers[place.section] ?? place.index
+}
+
+export function placeText(place: { section: string, index: number, title: string, block?: string }, t: ClassroomMessages, numbers?: SectionNumbers): string {
+  return t.place(placeIndex(place, numbers), place.title, place.block && isAuthorLabel(place.block) ? place.block : undefined)
+}
+
+export function isAuthorLabel(blockId: string): boolean {
+  return !/-\d+$/.test(blockId)
+}

package/src/domain/predict.ts

@@ -0,0 +1,34 @@
+import type { Place } from './place.ts'
+import { latestPerParticipant } from './tally.ts'
+
+export interface SavedPrediction {
+  choice?: number
+  text?: string
+  at: number
+}
+
+export interface Prediction extends Place, SavedPrediction {
+  predictId: string
+  participant: string
+  question: string
+  choices?: string[]
+}
+
+export function predictionId(predictId: string, participant: string): string {
+  return `${predictId}:${participant}`
+}
+
+export interface PredictionTally {
+  counts: number[]
+  respondents: number
+  texts: string[]
+}
+
+export function predictionTally(predictId: string, choices: number, predictions: Iterable<Prediction>): PredictionTally {
+  const last = latestPerParticipant([...predictions].filter(p => p.predictId === predictId)).sort((a, b) => a.at - b.at)
+  return {
+    counts: Array.from({ length: choices }, (_, i) => last.filter(p => p.choice === i).length),
+    respondents: last.length,
+    texts: last.flatMap(p => (p.text ? [p.text] : [])),
+  }
+}

package/src/domain/pulse.ts

@@ -0,0 +1,19 @@
+import type { Place } from './place.ts'
+import { latestPerParticipant } from './tally.ts'
+
+export interface PulseVote extends Place {
+  pulseId: string
+  participant: string
+  level: number
+  levels: string[]
+  at: number
+}
+
+export function voteId(pulseId: string, participant: string): string {
+  return `${pulseId}:${participant}`
+}
+
+export function pulseTally(pulseId: string, levels: number, votes: Iterable<PulseVote>): number[] {
+  const last = latestPerParticipant([...votes].filter(v => v.pulseId === pulseId))
+  return Array.from({ length: levels }, (_, i) => last.filter(v => v.level === i).length)
+}

package/src/domain/questions.ts

@@ -0,0 +1,42 @@
+import type { SectionNumbers } from './config.ts'
+import type { ClassroomMessages } from './messages.ts'
+import { placeIndex, placeText } from './place.ts'
+
+export interface Question {
+  section: string
+  block?: string
+  title: string
+  index: number
+  text: string
+  participant: string
+  name: string
+  at: number
+  answered?: boolean
+  reply?: QuestionReply
+}
+
+export interface QuestionReply {
+  text: string
+  provider?: string
+  at: number
+}
+
+export interface QuestionGroup<T extends Question> {
+  label: string
+  section: string
+  block?: string
+  questions: T[]
+}
+
+export function questionsByPlace<T extends Question>(questions: Iterable<T>, t: ClassroomMessages, numbers?: SectionNumbers): QuestionGroup<T>[] {
+  const groups = new Map<string, QuestionGroup<T> & { index: number }>()
+  for (const q of [...questions].sort((a, b) => a.at - b.at)) {
+    const key = `${q.section}\n${q.block ?? ''}`
+    let group = groups.get(key)
+    if (!group) groups.set(key, group = { label: placeText(q, t, numbers), section: q.section, block: q.block, index: placeIndex(q, numbers), questions: [] })
+    group.questions.push(q)
+  }
+  return [...groups.values()]
+    .sort((a, b) => a.index - b.index || (a.block ?? '').localeCompare(b.block ?? ''))
+    .map(({ index: _index, ...group }) => group)
+}

package/src/domain/quiz.ts

@@ -0,0 +1,63 @@
+import type { SessionStatus } from '@lincyaw/kernel'
+import type { Place } from './place.ts'
+import { latestPerParticipant } from './tally.ts'
+
+export interface QuizState extends Place {
+  open: boolean
+  options: string[]
+  correct: number[]
+  openedAt?: number
+  closedAt?: number
+  final?: Answer[]
+}
+
+export interface Answer {
+  quizId: string
+  participant: string
+  name: string
+  choice: number[]
+  at: number
+}
+
+export interface QuizTally {
+  counts: number[]
+  respondents: number
+  correct: number
+}
+
+export function answerId(quizId: string, participant: string): string {
+  return `${quizId}:${participant}`
+}
+
+export function isCorrect(choice: readonly number[], correct: readonly number[]): boolean {
+  const chosen = new Set(choice)
+  return chosen.size === correct.length && correct.every(i => chosen.has(i))
+}
+
+export function countedAnswers(quizId: string, state: QuizState | undefined, answers: Iterable<Answer>): Answer[] {
+  if (state?.open === false && state.final) return state.final
+  return latestPerParticipant([...answers].filter(a => a.quizId === quizId))
+}
+
+export function lateAnswers(quizId: string, state: QuizState | undefined, answers: Iterable<Answer>): Answer[] {
+  if (state?.open !== false || !state.final) return []
+  const counted = new Map(state.final.map(a => [a.participant, a.at]))
+  return latestPerParticipant([...answers].filter(a => a.quizId === quizId)).filter(a => counted.get(a.participant) !== a.at)
+}
+
+export function quizTally(options: number, correct: readonly number[], counted: readonly Answer[]): QuizTally {
+  const counts = Array.from({ length: options }, (_, i) => counted.filter(a => a.choice.includes(i)).length)
+  return { counts, respondents: counted.length, correct: counted.filter(a => isCorrect(a.choice, correct)).length }
+}
+
+export function quizSwitched(quiz: Omit<QuizState, 'open' | 'closedAt' | 'final'>, open: boolean, counted: readonly Answer[], now: number): QuizState {
+  return open ? { ...quiz, open, openedAt: now } : { ...quiz, open, closedAt: now, final: [...counted] }
+}
+
+export function acceptsAnswers(status: SessionStatus | undefined, state: QuizState | undefined): boolean {
+  return status === 'active' && state?.open === true
+}
+
+export function optionLetter(i: number): string {
+  return String.fromCharCode(65 + i)
+}

package/src/domain/records.ts

@@ -0,0 +1,97 @@
+import { isRecord } from '@lincyaw/kernel'
+import type { Submission } from './exercise.ts'
+import type { Note } from './notes.ts'
+import type { Prediction, SavedPrediction } from './predict.ts'
+import type { PulseVote } from './pulse.ts'
+import type { Question } from './questions.ts'
+import type { Answer, QuizState } from './quiz.ts'
+
+const isString = (value: unknown): value is string => typeof value === 'string'
+const isTime = (value: unknown): value is number => typeof value === 'number' && Number.isFinite(value)
+const isCount = (value: unknown): value is number => Number.isInteger(value) && (value as number) >= 0
+const isStrings = (value: unknown): value is string[] => Array.isArray(value) && value.every(isString)
+const isCounts = (value: unknown): value is number[] => Array.isArray(value) && value.every(isCount)
+
+function isPlace(value: Record<string, unknown>): boolean {
+  return isString(value.section) && isString(value.block) && isString(value.title) && isCount(value.index)
+}
+
+/**
+ * A record with the fields that earlier versions wrote under another name renamed: a classroom
+ * whose windows run different versions, or an archive, holds both.
+ */
+function renamed(value: Record<string, unknown>, before: string, now: string): Record<string, unknown> {
+  if (!(before in value)) return value
+  const { [before]: old, ...rest } = value
+  return now in rest ? rest : { ...rest, [now]: old }
+}
+
+export function toAnswer(value: unknown): Answer | undefined {
+  if (!isRecord(value)) return undefined
+  const answer = renamed(value, 'quiz', 'quizId')
+  return isString(answer.quizId) && isString(answer.participant) && isString(answer.name) && isCounts(answer.choice) && isTime(answer.at)
+    ? answer as unknown as Answer
+    : undefined
+}
+
+export function toQuizState(value: unknown): QuizState | undefined {
+  if (!isRecord(value)) return undefined
+  const state = renamed(value, 'answer', 'correct')
+  if (!(isPlace(state) && typeof state.open === 'boolean' && isStrings(state.options) && isCounts(state.correct))) return undefined
+  if (state.final === undefined) return state as unknown as QuizState
+  const final = Array.isArray(state.final) ? state.final.map(toAnswer) : undefined
+  return final?.every(answer => answer !== undefined) ? { ...state, final } as unknown as QuizState : undefined
+}
+
+export function toPulseVote(value: unknown): PulseVote | undefined {
+  if (!isRecord(value)) return undefined
+  const vote = renamed(value, 'pulse', 'pulseId')
+  return isPlace(vote) && isString(vote.pulseId) && isString(vote.participant) && isCount(vote.level) && isStrings(vote.levels) && isTime(vote.at)
+    ? vote as unknown as PulseVote
+    : undefined
+}
+
+export function toSubmission(value: unknown): Submission | undefined {
+  if (!isRecord(value)) return undefined
+  const submission = renamed(value, 'exercise', 'exerciseId')
+  return isPlace(submission) && isString(submission.exerciseId) && isString(submission.participant) && isString(submission.name)
+    && ['passed', 'failed', 'error'].includes(submission.status as string) && isCount(submission.passed) && isCount(submission.total)
+    && isStrings(submission.kinds) && isTime(submission.at)
+    ? submission as unknown as Submission
+    : undefined
+}
+
+export function toQuestion(value: unknown): Question | undefined {
+  if (!isRecord(value)) return undefined
+  const question = renamed(value, 'author', 'participant')
+  const { reply } = question
+  return isString(question.section) && (question.block === undefined || isString(question.block)) && isString(question.title)
+    && isCount(question.index) && isString(question.text) && isString(question.participant) && isString(question.name) && isTime(question.at)
+    && (question.answered === undefined || typeof question.answered === 'boolean')
+    && (reply === undefined || (isRecord(reply) && isString(reply.text) && isTime(reply.at) && (reply.provider === undefined || isString(reply.provider))))
+    ? question as unknown as Question
+    : undefined
+}
+
+export function toNote(value: unknown): Note | undefined {
+  return isRecord(value) && isString(value.section) && (value.block === undefined || isString(value.block)) && isString(value.text) && isTime(value.at)
+    ? value as unknown as Note
+    : undefined
+}
+
+function isSavedPrediction(value: Record<string, unknown>): boolean {
+  return (isCount(value.choice) || isString(value.text)) && isTime(value.at)
+}
+
+export function toSavedPrediction(value: unknown): SavedPrediction | undefined {
+  return isRecord(value) && isSavedPrediction(value) ? value as unknown as SavedPrediction : undefined
+}
+
+export function toPrediction(value: unknown): Prediction | undefined {
+  if (!isRecord(value)) return undefined
+  const prediction = renamed(value, 'predict', 'predictId')
+  return isPlace(prediction) && isString(prediction.predictId) && isString(prediction.participant) && isString(prediction.question)
+    && (prediction.choices === undefined || isStrings(prediction.choices)) && isSavedPrediction(prediction)
+    ? prediction as unknown as Prediction
+    : undefined
+}

package/src/domain/source.ts

@@ -0,0 +1,55 @@
+import type { MdastNode } from '@lincyaw/kernel'
+
+export interface QuizSource {
+  prompt: MdastNode[]
+  options: string[]
+  correct: number[]
+}
+
+function plainText(node: MdastNode): string {
+  return typeof node.value === 'string' ? node.value : (node.children ?? []).map(plainText).join('')
+}
+
+export function quizSource(body: MdastNode): QuizSource {
+  const prompt: MdastNode[] = []
+  const options: string[] = []
+  const correct: number[] = []
+  for (const node of body.children ?? []) {
+    const items = node.type === 'list' ? (node.children ?? []).filter(item => typeof item.checked === 'boolean') : []
+    if (items.length === 0) {
+      prompt.push(node)
+      continue
+    }
+    for (const item of items) {
+      if (item.checked) correct.push(options.length)
+      options.push(plainText(item).trim())
+    }
+  }
+  return { prompt, options, correct }
+}
+
+export interface CodeSource {
+  lang: string
+  value: string
+}
+
+export interface ExerciseSource {
+  prompt: MdastNode[]
+  code: CodeSource[]
+}
+
+export function exerciseSource(body: MdastNode): ExerciseSource {
+  const prompt: MdastNode[] = []
+  const code: CodeSource[] = []
+  for (const node of body.children ?? []) {
+    if (node.type === 'code') code.push({ lang: typeof node.lang === 'string' ? node.lang : '', value: String(node.value ?? '') })
+    else prompt.push(node)
+  }
+  return { prompt, code }
+}
+
+export function optionList(value: unknown): string[] | undefined {
+  const items = Array.isArray(value) ? value.map(String) : typeof value === 'string' ? value.split(/[,，]/) : []
+  const options = items.map(item => item.trim()).filter(Boolean)
+  return options.length >= 2 ? options : undefined
+}