cotutor 0.1.0 → 0.3.0

package/dist/board/cards/lecture.js

@@ -0,0 +1,62 @@
+/**
+ * 小课堂卡:老师答孩子时放课里的一段,不另讲一遍。正文第一行「<课包或视频的 id> 0:19-0:30」,第二行可以写一句给孩子的话。
+ * 拿现成的课包或视频(家长做的);时间照上下文包 lecture.lines 抄。
+ * 课名、真放的起止(对齐到段界,board/lecture.ts lectureRange)、能不能放(ready)、末帧停在 SVG 的哪一刻,都是服务端下发时从课包现算的快照(src/runtime/lecture.ts 的 enrichLectures)。
+ * 状态 = 那一段看完没;讲稿 [[play]] 锚到它:念到那句,铺满放那一段(课里原来的声音),放完停在末帧接着念。
+ */
+import { z } from 'zod';
+import { BUNDLE_ID_RE, bodyLines } from "./kind.js";
+import { clockLabel, parseClock } from "../lecture.js";
+export const LecturePropsSchema = z.object({
+    /** 课包 id(bundles/<id>/) */
+    bundle: z.string().regex(BUNDLE_ID_RE),
+    /** 老师写的起止(毫秒);不写止 = 起点那一段放完;都不写 = 整堂课 */
+    from: z.number().int().nonnegative().optional(),
+    to: z.number().int().nonnegative().optional(),
+    /** 老师在第二行写的一句(卡上标题下面一行) */
+    text: z.string().optional(),
+    /** 以下是下发时从课包算的快照 */
+    title: z.string().optional(),
+    /** 真放的起止(毫秒,对齐到段界) */
+    start: z.number().nonnegative().optional(),
+    end: z.number().nonnegative().optional(),
+    /** 末帧停在 SVG 的哪一刻(紧凑态缩略图) */
+    still: z.number().nonnegative().optional(),
+    /** 课包读得出来、起止对得上 */
+    ready: z.boolean().optional(),
+    /** 这一课是视频(lectures/<id>/video.mp4),不是课包 */
+    video: z.boolean().optional(),
+});
+export const LectureStateSchema = z.object({ done: z.boolean() });
+export const lecture = {
+    name: 'lecture',
+    props: LecturePropsSchema,
+    parse(body) {
+        const [first, ...rest] = bodyLines(body);
+        const [bundle, range, ...more] = (first ?? '').split(/\s+/).filter(Boolean);
+        if (!bundle)
+            throw new Error('第一行要是课包 id 和一段时间,照上下文包 lecture.source 与 lines 抄,如 2026-09-18-po13-jian-8 0:19-0:30');
+        if (!BUNDLE_ID_RE.test(bundle))
+            throw new Error(`课包 id 只能是小写字母、数字、连字符:${bundle}`);
+        if (more.length)
+            throw new Error(`第一行只写课包 id 和一段时间:${first}`);
+        let from;
+        let to;
+        if (range) {
+            const [a, b, ...c] = range.split(/[-–~]/);
+            from = parseClock(a) ?? undefined;
+            to = b === undefined ? undefined : (parseClock(b) ?? undefined);
+            if (from === undefined || (b !== undefined && to === undefined) || c.length)
+                throw new Error(`时间写成「分:秒-分:秒」,如 0:19-0:30:${range}`);
+            if (to !== undefined && to <= from)
+                throw new Error(`止要在起之后:${range}`);
+        }
+        const text = rest.join(' ').trim();
+        return { bundle, ...(from !== undefined ? { from } : {}), ...(to !== undefined ? { to } : {}), ...(text ? { text } : {}) };
+    },
+    state: LectureStateSchema,
+    describe(p, s) {
+        const at = p.from !== undefined ? `(${clockLabel(p.from)}${p.to !== undefined ? `–${clockLabel(p.to)}` : ''})` : '';
+        return s.done ? `看完了这一段${at}` : `还没看完这一段${at}`;
+    },
+};

package/dist/board/cards/paint.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 画图卡(kind 名 paint):老师把孩子说清楚的故事分好幅,应用交给百炼画成一张连环画(四格时 2×2,同练习册)。
+ * 正文:`题:` 题干、`词:` 词语宝库(出题版才有)、`角色:` 一行一个(每幅都画同一个样子靠它)、`1.` 起一幅一行。
+ * 画是这张卡的资产:一轮跑完后台画(src/scenes/paint/),图落在 .cards/<n>/paint.png;下发时由 enrichPaints 补上画好没有。孩子端没有错误:没画成就停在分幅那几句。
+ */
+import { z } from 'zod';
+import { type CardKind } from './kind.ts';
+/** 最多几幅:四格(2×2)是练习册的样子 */
+export declare const PAINT_PANELS_MAX = 4;
+/** 一幅最多几个字 */
+export declare const PAINT_PANEL_MAX = 80;
+/** 最多几个角色(一幅最多画三个,整个故事给四个) */
+export declare const PAINT_CAST_MAX = 4;
+/** 词语宝库最多几个词 */
+export declare const PAINT_WORDS_MAX = 8;
+export declare const PaintCastSchema: z.ZodObject<{
+    name: z.ZodString;
+    look: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PaintCast = z.infer<typeof PaintCastSchema>;
+export declare const PaintPropsSchema: z.ZodObject<{
+    panels: z.ZodArray<z.ZodString>;
+    cast: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        look: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    ask: z.ZodOptional<z.ZodString>;
+    words: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    pic: z.ZodOptional<z.ZodString>;
+    drawn: z.ZodOptional<z.ZodEnum<{
+        done: "done";
+        drawing: "drawing";
+        none: "none";
+    }>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PaintProps = z.infer<typeof PaintPropsSchema>;
+export declare const paint: CardKind<PaintProps>;

package/dist/board/cards/paint.js

@@ -0,0 +1,85 @@
+/**
+ * 画图卡(kind 名 paint):老师把孩子说清楚的故事分好幅,应用交给百炼画成一张连环画(四格时 2×2,同练习册)。
+ * 正文:`题:` 题干、`词:` 词语宝库(出题版才有)、`角色:` 一行一个(每幅都画同一个样子靠它)、`1.` 起一幅一行。
+ * 画是这张卡的资产:一轮跑完后台画(src/scenes/paint/),图落在 .cards/<n>/paint.png;下发时由 enrichPaints 补上画好没有。孩子端没有错误:没画成就停在分幅那几句。
+ */
+import { z } from 'zod';
+import { bodyLines } from "./kind.js";
+/** 最多几幅:四格(2×2)是练习册的样子 */
+export const PAINT_PANELS_MAX = 4;
+/** 一幅最多几个字 */
+export const PAINT_PANEL_MAX = 80;
+/** 最多几个角色(一幅最多画三个,整个故事给四个) */
+export const PAINT_CAST_MAX = 4;
+/** 词语宝库最多几个词 */
+export const PAINT_WORDS_MAX = 8;
+export const PaintCastSchema = z.object({
+    name: z.string().min(1),
+    /** 样子、颜色、衣服;孩子没说就不写(只有名字,画家照名字画,每幅一样就行) */
+    look: z.string().min(1).optional(),
+});
+export const PaintPropsSchema = z.object({
+    /** 一幅一句,只写看得见的;一到四幅 */
+    panels: z.array(z.string().min(1)).min(1).max(PAINT_PANELS_MAX),
+    cast: z.array(PaintCastSchema).max(PAINT_CAST_MAX).optional(),
+    /** 题干(出题版) */
+    ask: z.string().min(1).optional(),
+    /** 词语宝库(出题版) */
+    words: z.array(z.string().min(1)).max(PAINT_WORDS_MAX).optional(),
+    /** 下发时补的(enrichPaints):画好了是图的路径(相对 workspace 根),还在画 drawing,没画成 none;老师写不出来 */
+    pic: z.string().optional(),
+    drawn: z.enum(['drawing', 'done', 'none']).optional(),
+    /** 家长端才补的:用的模型、画了几秒、没画成的原因 */
+    note: z.string().optional(),
+});
+/** 「题:」「词:」「角色:」;中英文冒号都认(全角写成 \uFF1A,一眼看得出两种都在;原来少了全角那个,2026-10-12 qwen 写「题：」整张卡退成文字) */
+const FIELD = /^(题干?|词语?宝库|词|角色)\s*[:\uFF1A]\s*(.*)$/;
+/** 「1.」「1、」「1)」「第1幅:」「第 1 格:」 */
+const PANEL = /^(?:第\s*)?([1-9])\s*(?:[.、)\uFF0E\uFF09]|幅\s*[:\uFF1A]?|格\s*[:\uFF1A]?)\s*(.+)$/;
+const WORD_SEP = /[、,\uFF0C;\uFF1B\s]+/;
+export const paint = {
+    name: 'paint',
+    props: PaintPropsSchema,
+    parse(body) {
+        const panels = [];
+        const cast = [];
+        let ask;
+        let words = [];
+        for (const line of bodyLines(body)) {
+            const f = FIELD.exec(line);
+            if (f) {
+                const v = f[2].trim();
+                if (!v)
+                    continue;
+                if (f[1].startsWith('题'))
+                    ask = v;
+                else if (f[1] === '角色') {
+                    // 「名字:样子」;孩子没说样子就只写名字(2026-10-12 qwen 照「只写孩子说过的」写了「角色: 小熊」,整张卡退成文字)
+                    const m = /^([^:\uFF1A]+)[:\uFF1A]\s*(.+)$/.exec(v);
+                    cast.push(m ? { name: m[1].trim(), look: m[2].trim() } : { name: v });
+                }
+                else
+                    words = v.split(WORD_SEP).map((w) => w.trim()).filter(Boolean);
+                continue;
+            }
+            const p = PANEL.exec(line);
+            if (p) {
+                const text = p[2].trim();
+                if (Array.from(text).length > PAINT_PANEL_MAX)
+                    throw new Error(`第 ${p[1]} 幅超过 ${PAINT_PANEL_MAX} 个字;一幅只画一件事`);
+                panels.push(text);
+                continue;
+            }
+            throw new Error(`认不出这一行(要是「题:」「词:」「角色:」或「1.」开头的一幅):${line}`);
+        }
+        if (!panels.length)
+            throw new Error('一幅都没有:一幅一行,「1.」开头');
+        if (panels.length > PAINT_PANELS_MAX)
+            throw new Error(`${panels.length} 幅,最多 ${PAINT_PANELS_MAX} 幅`);
+        if (cast.length > PAINT_CAST_MAX)
+            throw new Error(`${cast.length} 个角色,最多 ${PAINT_CAST_MAX} 个`);
+        if (words.length > PAINT_WORDS_MAX)
+            throw new Error(`${words.length} 个词,最多 ${PAINT_WORDS_MAX} 个`);
+        return { panels, ...(cast.length ? { cast } : {}), ...(ask ? { ask } : {}), ...(words.length ? { words } : {}) };
+    },
+};

package/dist/board/cards/photo.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 拍给我看卡(《卡片协议.md》「拍给我看卡」):老师要孩子拍一张照片发来——看图说话的那幅图、写好的那一页。
+ * 卡上是相机与要拍什么;它在最后一节时下沿是答案栏「等你拍…」带「拍照」「相册」,点了走老师页那套发照片屏(裁、圈、配一句话),
+ * 发出去那条消息的照片(与配的话)落回这张卡的答案栏(board/presentation.ts 的 askCard / kidSaid)。照片随消息交给老师,卡自己不存状态。
+ * 起因:看图说话老师说「把那幅图拍下来,好吗?」,末句是问句,解析器补了提问卡,孩子端写的是「等你说…」。
+ */
+import { z } from 'zod';
+import { type CardKind } from './kind.ts';
+/** 要拍什么,最多几个字:一行说清,卡上一眼读完 */
+export declare const PHOTO_TEXT_MAX = 30;
+export declare const PhotoPropsSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strip>;
+export type PhotoProps = z.infer<typeof PhotoPropsSchema>;
+export declare const photo: CardKind<PhotoProps>;

package/dist/board/cards/photo.js

@@ -0,0 +1,29 @@
+/**
+ * 拍给我看卡(《卡片协议.md》「拍给我看卡」):老师要孩子拍一张照片发来——看图说话的那幅图、写好的那一页。
+ * 卡上是相机与要拍什么;它在最后一节时下沿是答案栏「等你拍…」带「拍照」「相册」,点了走老师页那套发照片屏(裁、圈、配一句话),
+ * 发出去那条消息的照片(与配的话)落回这张卡的答案栏(board/presentation.ts 的 askCard / kidSaid)。照片随消息交给老师,卡自己不存状态。
+ * 起因:看图说话老师说「把那幅图拍下来,好吗?」,末句是问句,解析器补了提问卡,孩子端写的是「等你说…」。
+ */
+import { z } from 'zod';
+import { bodyLines } from "./kind.js";
+/** 要拍什么,最多几个字:一行说清,卡上一眼读完 */
+export const PHOTO_TEXT_MAX = 30;
+export const PhotoPropsSchema = z.object({
+    /** 要拍什么(「看图说话的那幅图」「写好的那一页」) */
+    text: z.string().min(1),
+});
+export const photo = {
+    name: 'photo',
+    props: PhotoPropsSchema,
+    parse(body) {
+        const lines = bodyLines(body);
+        if (!lines.length)
+            throw new Error('写一行:要孩子拍什么');
+        if (lines.length > 1)
+            throw new Error('一张卡一行:要拍什么');
+        const n = Array.from(lines[0]).length;
+        if (n > PHOTO_TEXT_MAX)
+            throw new Error(`${n} 个字,最多 ${PHOTO_TEXT_MAX} 个;说清要拍什么就够`);
+        return { text: lines[0] };
+    },
+};

package/dist/board/cards/read.d.ts

@@ -0,0 +1,8 @@
+/** 点读卡:一行一段,孩子点哪段听哪段;配音在一轮跑完后后台按段合成到 .cards/<n>/<段>.mp3,还没好的段退浏览器合成声。 */
+import { z } from 'zod';
+import { type CardKind } from './kind.ts';
+export declare const ReadPropsSchema: z.ZodObject<{
+    segments: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ReadProps = z.infer<typeof ReadPropsSchema>;
+export declare const read: CardKind<ReadProps>;

package/dist/board/cards/read.js

@@ -0,0 +1,18 @@
+/** 点读卡:一行一段,孩子点哪段听哪段;配音在一轮跑完后后台按段合成到 .cards/<n>/<段>.mp3,还没好的段退浏览器合成声。 */
+import { z } from 'zod';
+import { bodyLines } from "./kind.js";
+export const ReadPropsSchema = z.object({ segments: z.array(z.string().min(1)).min(1) });
+export const read = {
+    name: 'read',
+    where: ['board', 'home'],
+    props: ReadPropsSchema,
+    parse(body) {
+        const segments = bodyLines(body);
+        if (!segments.length)
+            throw new Error('一行都没有(一行一段)');
+        return { segments };
+    },
+    assets(p) {
+        return p.segments.map((text, k) => ({ file: `${k + 1}.mp3`, text }));
+    },
+};

package/dist/board/cards/text.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 文字卡:一段字。正文第一行以 `#` 开头就是标题(2026-09-12:样子归主题,老师只写 ```text);
+ * 只有一行 `# 标题` 没正文 = 小节标题(heading:渲染成无底加粗一行,不算一张卡)。
+ * 修饰词只有 formula(算式,衬线居中);别的修饰词不认,整段当正文。
+ */
+import { z } from 'zod';
+import type { CardKind } from './kind.ts';
+export declare const TEXT_STYLES: readonly ["formula"];
+export type TextStyle = (typeof TEXT_STYLES)[number];
+export declare const TextPropsSchema: z.ZodObject<{
+    style: z.ZodOptional<z.ZodEnum<{
+        formula: "formula";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    text: z.ZodString;
+    heading: z.ZodOptional<z.ZodBoolean>;
+    ask: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type TextProps = z.infer<typeof TextPropsSchema>;
+export declare const text: CardKind<TextProps>;

package/dist/board/cards/text.js

@@ -0,0 +1,59 @@
+/**
+ * 文字卡:一段字。正文第一行以 `#` 开头就是标题(2026-09-12:样子归主题,老师只写 ```text);
+ * 只有一行 `# 标题` 没正文 = 小节标题(heading:渲染成无底加粗一行,不算一张卡)。
+ * 修饰词只有 formula(算式,衬线居中);别的修饰词不认,整段当正文。
+ */
+import { z } from 'zod';
+export const TEXT_STYLES = ['formula'];
+export const TextPropsSchema = z.object({
+    style: z.enum(TEXT_STYLES).optional(),
+    /** 第一行 `# 标题` */
+    title: z.string().optional(),
+    /** 正文 */
+    text: z.string(),
+    /** 小节标题行(只有 `# 标题`):不算卡 */
+    heading: z.boolean().optional(),
+    /** 提问卡:解析器在末句问句没配能答的卡时补的(老师写不出来),text 就是那句问话 */
+    ask: z.boolean().optional(),
+});
+/**
+ * 文字卡里的答案行:老师把填空卡的「= 答案」写进了文字卡(10-20 21:24「( )穷( )尽,填两个字。= 山 = 水」),
+ * 文字卡原来不剥,答案上了孩子的板。正文里有空(___、( ))时,「= 」开头的行算答案:下发前剥掉,家长视图报一句。
+ * 没有空的照旧(算式一步一步往下写「= 24 ÷ 2」是正文)
+ */
+const ANSWER_LINE = /^\s*=\s/;
+const BLANK = /_{2,}|[(（][\s　]*[)）]/;
+function answerLines(text) {
+    const lines = text.split('\n');
+    const kept = lines.filter((l) => !ANSWER_LINE.test(l));
+    if (kept.length === lines.length || !BLANK.test(kept.join('\n')))
+        return { kept: text, dropped: 0 };
+    return { kept: kept.join('\n').trim(), dropped: lines.length - kept.length };
+}
+export const text = {
+    name: 'text',
+    where: ['board', 'home'],
+    props: TextPropsSchema,
+    parse(body, mods) {
+        const style = mods.map((m) => m.toLowerCase()).find((m) => TEXT_STYLES.includes(m));
+        const trimmed = body.replace(/^\s*\n/, '').trimEnd();
+        if (!trimmed.trim())
+            throw new Error('正文是空的');
+        const hd = /^#{1,3}\s+(\S.*)$/.exec(trimmed.split('\n')[0] ?? '');
+        if (hd && !style) {
+            const nl = trimmed.indexOf('\n');
+            const rest = nl < 0 ? '' : trimmed.slice(nl + 1).trim();
+            const title = hd[1].trim();
+            return rest ? { title, text: rest } : { title, text: '', heading: true };
+        }
+        return { ...(style ? { style } : {}), text: trimmed.trim() };
+    },
+    note(_body, p) {
+        const { dropped } = answerLines(p.text);
+        return dropped ? `文字卡里 ${dropped} 行「= …」像答案,孩子端不显示(要孩子做的出 choice 卡,或请他开口说)` : null;
+    },
+    strip(p) {
+        const { kept, dropped } = answerLines(p.text);
+        return dropped ? { ...p, text: kept } : p;
+    },
+};

package/dist/board/cards/tianzige.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 田字格卡(kind 名 tianzige):一到四个汉字,孩子端每个字一个田字格,讲到这张卡时逐笔写一遍,之后点哪个字哪个字再写一遍。
+ * 笔顺数据是确定性资源(hanzi-writer-data,服务 /api/kid/tianzige/<字> 现读),老师只写字,不写笔画、不数笔画。没有状态。
+ * 第二行可以写拼音(一字一个音节,声调符号或数字调),孩子端标在格子上方;多音字按这句话里的读法,老师写(《卡片协议.md》)。
+ * 拼音对不上字数、不像拼音:卡照常只写字,家长视图报一句(note)。
+ */
+import { z } from 'zod';
+import type { CardKind } from './kind.ts';
+export declare const TianzigePropsSchema: z.ZodObject<{
+    chars: z.ZodString;
+    pinyin: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type TianzigeProps = z.infer<typeof TianzigePropsSchema>;
+export declare const HAN: RegExp;
+export declare const TIANZIGE_MAX = 4;
+export declare const tianzige: CardKind<TianzigeProps>;

package/dist/board/cards/tianzige.js

@@ -0,0 +1,64 @@
+/**
+ * 田字格卡(kind 名 tianzige):一到四个汉字,孩子端每个字一个田字格,讲到这张卡时逐笔写一遍,之后点哪个字哪个字再写一遍。
+ * 笔顺数据是确定性资源(hanzi-writer-data,服务 /api/kid/tianzige/<字> 现读),老师只写字,不写笔画、不数笔画。没有状态。
+ * 第二行可以写拼音(一字一个音节,声调符号或数字调),孩子端标在格子上方;多音字按这句话里的读法,老师写(《卡片协议.md》)。
+ * 拼音对不上字数、不像拼音:卡照常只写字,家长视图报一句(note)。
+ */
+import { z } from 'zod';
+import { toneMark } from "../presentation.js";
+export const TianzigePropsSchema = z.object({
+    /** 要写的字,1–4 个汉字,连着写 */
+    chars: z.string().min(1),
+    /** 每个字的拼音(带调号,一字一个);没写或对不上 = 没有 */
+    pinyin: z.array(z.string().min(1)).optional(),
+});
+export const HAN = /^\p{Script=Han}$/u;
+export const TIANZIGE_MAX = 4;
+/** 一个音节:数字调(gu3,轻声可不写数字)或一个调号(gǔ),不混写 */
+const SYLLABLE = /^(?:[a-zü]+[1-5]?|[a-zü]*[āáǎàēéěèīíǐìōóǒòūúǔùǖǘǚǜ][a-zü]*)$/;
+const VOWEL = /[aeiouüāáǎàēéěèīíǐìōóǒòūúǔùǖǘǚǜ]/;
+const HAS_HAN = /\p{Script=Han}/u;
+/** 正文 → 字那几行(连起来)与拼音那几行(没有汉字的行) */
+function split(body) {
+    const lines = body.split('\n').map((l) => l.trim()).filter(Boolean);
+    const han = lines.filter((l) => HAS_HAN.test(l));
+    const py = lines.filter((l) => !HAS_HAN.test(l));
+    // 一行汉字都没有:当它是要写的字(报「不是汉字」),不当拼音
+    if (!han.length)
+        return { chars: Array.from(body.replace(/\s+/g, '')), pinyin: null };
+    return { chars: Array.from(han.join('').replace(/\s+/g, '')), pinyin: py.length ? py.join(' ') : null };
+}
+/** 拼音那行 → 每字一个带调号的音节;对不上 → why */
+function readPinyin(line, n) {
+    const syl = line.toLowerCase().replace(/v/g, 'ü').split(/\s+/).filter(Boolean);
+    const bad = syl.find((s) => !SYLLABLE.test(s) || !VOWEL.test(s));
+    if (bad)
+        return { why: `「${bad}」不像拼音` };
+    if (syl.length !== n)
+        return { why: `拼音 ${syl.length} 个音节,字 ${n} 个,要一字一个` };
+    return { pinyin: syl.map(toneMark) };
+}
+export const tianzige = {
+    name: 'tianzige',
+    where: ['board', 'home'],
+    props: TianzigePropsSchema,
+    parse(body) {
+        const { chars, pinyin } = split(body);
+        if (!chars.length)
+            throw new Error('要写的字呢(一到四个汉字)');
+        const bad = chars.find((c) => !HAN.test(c));
+        if (bad)
+            throw new Error(`「${bad}」不是汉字;拼音写在第二行,标点写在讲稿里`);
+        if (chars.length > TIANZIGE_MAX)
+            throw new Error(`一张卡最多 ${TIANZIGE_MAX} 个字(给了 ${chars.length} 个),拆成两张`);
+        const py = pinyin ? readPinyin(pinyin, chars.length) : null;
+        return { chars: chars.join(''), ...(py && 'pinyin' in py ? { pinyin: py.pinyin } : {}) };
+    },
+    note(body, props) {
+        const { pinyin } = split(body);
+        if (!pinyin || props.pinyin)
+            return null;
+        const py = readPinyin(pinyin, Array.from(props.chars).length);
+        return 'why' in py ? `田字格的拼音没用上(${py.why}),只写了字` : null;
+    },
+};

package/dist/board/cards/tutor.d.ts

@@ -0,0 +1,72 @@
+/**
+ * 老师卡(kind 名 tutor,只用在首页):一位老师 + 几个按钮,孩子点了进这位老师。
+ * 标签修饰 = 老师的键;正文一行一个按钮:`接着 <日期> <话题> <字>` 接着那天的那个话题,`小课堂 <课包 id> <字>` 先看那份课包再聊,其余行是开场按钮;
+ * `讲法:` 行挂在上一个按钮下面,是家长和 LLM 写给老师的,strip 剥掉,孩子端 JSON 里没有;`留到: <日期>` 也挂在上一个按钮下面,过了那天孩子端不再出现(家长端表单的「只今天 / 到周日」)。
+ * 小课堂按钮下面 `activity: <名>` 挂一个 activity,看完开口那条起照它带。
+ * `activity <名> [孩子看到的字]` 进那个 activity(agents/<老师>/activities/<名>.md);它下面 `名: 值` 的行是这个 activity 的参数,和讲法一样 strip 剥掉。
+ * 「新话题」应用永远放第一个,不进 props。老师在不在、话题在不在,由首页检查(src/runtime/home/store.ts)查。
+ */
+import { z } from 'zod';
+import { type CardKind } from './kind.ts';
+export declare const TUTOR_BUTTONS_MAX = 4;
+export declare const BUTTON_LABEL_MAX = 16;
+export declare const TutorButtonSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"start">;
+    label: z.ZodString;
+    brief: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"continue">;
+    label: z.ZodString;
+    date: z.ZodString;
+    thread: z.ZodString;
+    brief: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"lecture">;
+    label: z.ZodString;
+    bundle: z.ZodString;
+    brief: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    activity: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"activity">;
+    label: z.ZodString;
+    activity: z.ZodString;
+    params: z.ZodRecord<z.ZodString, z.ZodString>;
+    brief: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+export type TutorButton = z.infer<typeof TutorButtonSchema>;
+export declare const TutorPropsSchema: z.ZodObject<{
+    tutor: z.ZodString;
+    buttons: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"start">;
+        label: z.ZodString;
+        brief: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"continue">;
+        label: z.ZodString;
+        date: z.ZodString;
+        thread: z.ZodString;
+        brief: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"lecture">;
+        label: z.ZodString;
+        bundle: z.ZodString;
+        brief: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+        activity: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"activity">;
+        label: z.ZodString;
+        activity: z.ZodString;
+        params: z.ZodRecord<z.ZodString, z.ZodString>;
+        brief: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export type TutorProps = z.infer<typeof TutorPropsSchema>;
+export declare const tutor: CardKind<TutorProps>;

package/dist/board/cards/tutor.js

@@ -0,0 +1,134 @@
+/**
+ * 老师卡(kind 名 tutor,只用在首页):一位老师 + 几个按钮,孩子点了进这位老师。
+ * 标签修饰 = 老师的键;正文一行一个按钮:`接着 <日期> <话题> <字>` 接着那天的那个话题,`小课堂 <课包 id> <字>` 先看那份课包再聊,其余行是开场按钮;
+ * `讲法:` 行挂在上一个按钮下面,是家长和 LLM 写给老师的,strip 剥掉,孩子端 JSON 里没有;`留到: <日期>` 也挂在上一个按钮下面,过了那天孩子端不再出现(家长端表单的「只今天 / 到周日」)。
+ * 小课堂按钮下面 `activity: <名>` 挂一个 activity,看完开口那条起照它带。
+ * `activity <名> [孩子看到的字]` 进那个 activity(agents/<老师>/activities/<名>.md);它下面 `名: 值` 的行是这个 activity 的参数,和讲法一样 strip 剥掉。
+ * 「新话题」应用永远放第一个,不进 props。老师在不在、话题在不在,由首页检查(src/runtime/home/store.ts)查。
+ */
+import { z } from 'zod';
+import { BUNDLE_ID_RE } from "./kind.js";
+export const TUTOR_BUTTONS_MAX = 4;
+export const BUTTON_LABEL_MAX = 16;
+const NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+const DAY_RE = /^\d{4}-\d{2}-\d{2}$/;
+const THREAD_RE = /^\d{4}-\d+$/;
+const LIST_PREFIX = /^(?:[-*+]|\d+[.)])\s+/;
+const BRIEF_LINE = /^讲法\s*[:：]\s*(.*)$/;
+const UNTIL_LINE = /^留到\s*[:：]\s*(.*)$/;
+const CONTINUE_LINE = /^接着\s+/;
+const LECTURE_LINE = /^小课堂\s+/;
+const ACTIVITY_LINE = /^activity(?:\s|$)/;
+/** activity 按钮下面的参数行:名: 值 */
+const PARAM_LINE = /^([^\s:：]+)\s*[:：]\s*(.*)$/;
+/** 小课堂按钮下面挂一个 activity:看完开口那条起照那个 activity 带(参数用缺省) */
+const LECTURE_ACTIVITY = /^activity\s*[:：]\s*(.*)$/;
+const label = z.string().min(1).refine((s) => Array.from(s).length <= BUTTON_LABEL_MAX, `按钮的字最多 ${BUTTON_LABEL_MAX} 个`);
+/** 留到哪天(含那天);过了孩子端不再出现 */
+const until = z.string().regex(DAY_RE).optional();
+export const TutorButtonSchema = z.discriminatedUnion('kind', [
+    /** 开场:孩子点了就把 label 发给老师(新话题),老师照 brief 开讲 */
+    z.object({ kind: z.literal('start'), label, brief: z.string().min(1).optional(), until }),
+    /** 接着:那天的那个话题;今天的 resume,以前的新开会话、上下文包带那个话题的尾巴 */
+    z.object({ kind: z.literal('continue'), label, date: z.string().regex(DAY_RE), thread: z.string().regex(THREAD_RE), brief: z.string().min(1).optional(), until }),
+    /** 小课堂:孩子点了先看这份课包(铺满、一口气放完),看完才能开口;开口那条新开话题,老师拿到课的每句与孩子画的地方 */
+    z.object({ kind: z.literal('lecture'), label, bundle: z.string().regex(BUNDLE_ID_RE), brief: z.string().min(1).optional(), until, activity: z.string().min(1).optional() }),
+    /** activity:孩子点了新开话题、把 label 发给老师;老师照那个 activity 文件带,params 是家长填的(原文,对不对由首页检查读 activity 文件查) */
+    z.object({ kind: z.literal('activity'), label, activity: z.string().min(1), params: z.record(z.string(), z.string()), brief: z.string().min(1).optional(), until }),
+]);
+export const TutorPropsSchema = z.object({
+    /** 老师的键(cotutor.json tutors 里的,-tutor 结尾) */
+    tutor: z.string().regex(NAME_RE),
+    buttons: z.array(TutorButtonSchema).max(TUTOR_BUTTONS_MAX),
+});
+export const tutor = {
+    name: 'tutor',
+    where: ['home'],
+    props: TutorPropsSchema,
+    parse(body, mods) {
+        const name = mods[0]?.toLowerCase();
+        if (!name)
+            throw new Error('标签后面写老师的键,如 ```tutor chinese-tutor');
+        if (!NAME_RE.test(name))
+            throw new Error(`「${mods[0]}」不是老师的键(cotutor.json tutors 里的英文名,如 chinese-tutor)`);
+        if (mods.length > 1)
+            throw new Error(`一张老师卡只写一位老师(多了 ${mods.slice(1).join(' ')})`);
+        const buttons = [];
+        for (const raw of body.split('\n')) {
+            const line = raw.trim().replace(LIST_PREFIX, '');
+            if (!line)
+                continue;
+            const brief = BRIEF_LINE.exec(line);
+            if (brief) {
+                const last = buttons[buttons.length - 1];
+                if (!last)
+                    throw new Error('「讲法:」前面要有一个按钮(讲法挂在上一个按钮下面)');
+                const text = brief[1].trim();
+                if (text)
+                    last.brief = last.brief ? `${last.brief}\n${text}` : text;
+                continue;
+            }
+            const keep = UNTIL_LINE.exec(line);
+            if (keep) {
+                const last = buttons[buttons.length - 1];
+                if (!last)
+                    throw new Error('「留到:」前面要有一个按钮(留到挂在上一个按钮下面)');
+                const day = keep[1].trim();
+                if (!DAY_RE.test(day))
+                    throw new Error(`「${line}」:留到要写日期,如「留到: 2026-10-12」(那天过完孩子就看不到这个按钮)`);
+                last.until = day;
+                continue;
+            }
+            if (line === '新话题')
+                continue;
+            const last = buttons[buttons.length - 1];
+            const hang = LECTURE_ACTIVITY.exec(line);
+            if (hang) {
+                if (last?.kind !== 'lecture')
+                    throw new Error(`「${line}」:activity: 只挂在小课堂按钮下面;要一个 activity 按钮,写「activity <名>」`);
+                const name = hang[1].trim();
+                if (!/^\S+$/.test(name))
+                    throw new Error(`「${line}」:activity: 后面写一个 activity 的名字,如「activity: 看图说话」`);
+                last.activity = name;
+                continue;
+            }
+            const param = last?.kind === 'activity' ? PARAM_LINE.exec(line) : null;
+            if (last?.kind === 'activity' && param) {
+                if (param[1] in last.params)
+                    throw new Error(`「${line}」:参数 ${param[1]} 写了两次`);
+                last.params[param[1]] = param[2].trim();
+                continue;
+            }
+            if (CONTINUE_LINE.test(line)) {
+                const m = /^接着\s+(\S+)\s+(\S+)\s+(.+)$/.exec(line);
+                if (!m || !DAY_RE.test(m[1]) || !THREAD_RE.test(m[2]))
+                    throw new Error(`「${line}」:接着要写成「接着 <日期> <话题> <孩子看到的字>」,如「接着 2026-09-16 1930-1 接着写看图写话」`);
+                buttons.push({ kind: 'continue', date: m[1], thread: m[2], label: m[3].trim() });
+            }
+            else if (LECTURE_LINE.test(line)) {
+                const m = /^小课堂\s+(\S+)\s+(.+)$/.exec(line);
+                if (!m || !BUNDLE_ID_RE.test(m[1]))
+                    throw new Error(`「${line}」:小课堂要写成「小课堂 <课包 id> <孩子看到的字>」,如「小课堂 2026-09-18-po13-jian-8 13 减 8 怎么拆」`);
+                buttons.push({ kind: 'lecture', bundle: m[1], label: m[2].trim() });
+            }
+            else if (ACTIVITY_LINE.test(line)) {
+                const m = /^activity\s+(\S+)(?:\s+(.+))?$/.exec(line);
+                if (!m)
+                    throw new Error(`「${line}」:activity 要写成「activity <名> [孩子看到的字]」,如「activity 你说我画」`);
+                buttons.push({ kind: 'activity', activity: m[1], label: (m[2] ?? m[1]).trim(), params: {} });
+            }
+            else
+                buttons.push({ kind: 'start', label: line });
+            const cps = Array.from(buttons[buttons.length - 1].label).length;
+            if (cps > BUTTON_LABEL_MAX)
+                throw new Error(`按钮「${buttons[buttons.length - 1].label}」${cps} 个字,最多 ${BUTTON_LABEL_MAX} 个;要跟老师说的挪到下一行的「讲法:」里`);
+        }
+        if (buttons.length > TUTOR_BUTTONS_MAX)
+            throw new Error(`按钮最多 ${TUTOR_BUTTONS_MAX} 个(「新话题」不算),写了 ${buttons.length} 个`);
+        return { tutor: name, buttons };
+    },
+    strip(props) {
+        // 讲法与 activity 的参数是写给老师的,孩子端不要
+        return { ...props, buttons: props.buttons.map(({ brief: _brief, ...b }) => (b.kind === 'activity' ? { ...b, params: {} } : b)) };
+    },
+};