cotutor 0.2.0 → 0.4.0

package/dist/runtime/delivery/player.d.ts

@@ -0,0 +1,145 @@
+/**
+ * 实时老师的孩子端:谁出声、谁停、谁让谁(见 tests/live-player.test.ts)。纯函数,页面只 dispatch、照单执行。
+ * 实时时孩子端不念讲稿(嘴照念,声音从 WebSocket 下来,src/runtime/live/call.ts);出声的只有嘴和卡自己的声音(朗读卡点读、单词卡)。
+ * 板上的节(铺、写完、撤掉)是另一个状态机 board/presentation.ts 的 step;这里只管声音。
+ * 改规则的顺序:先改 tests/live-player.test.ts 的预期 → 再改这里。
+ * 一直听(全双工):孩子不用按,服务端的 VAD 判开口 / 说完;推不推孩子的声音是状态的函数(liveGate),一变就告诉服务端 gate。
+ * 口语课:热身的 [[echo]] / [[say]] 那句放完,那张卡亮「轮到你」(turn);[[call]] 那句放完响铃(孩子端自己的声音),嘴一出声铃停。
+ * 字幕重放:字幕下「再听一遍」,孩子端放这一轮嘴照念过的声音(服务端按轮留的那份);只在安静、脑不在写时开始,不告诉服务端任何东西。
+ */
+/** quiet 安静 · holding 孩子按着说话 · mouth 嘴的声音在放(或还在来)· card 卡的声音在念 · lecture 在放小课堂卡上那一段(讲稿的 [[play]])· ring 在响铃(讲稿的 [[call]])· replay 在重放这一轮嘴说过的 */
+export type LiveStatus = 'quiet' | 'holding' | 'mouth' | 'card' | 'lecture' | 'ring' | 'replay';
+export interface LiveModel {
+    status: LiveStatus;
+    /** 孩子按下时嘴正在说:字幕上那句变淡、加省略号;嘴再出声就清 */
+    cut: boolean;
+    /** 一直听开着(口语课,或老师配了 live.listen);hearing = 服务端说孩子在说;ducked = 嘴的声音压低着;muted = 孩子点胶囊关了麦 */
+    open: boolean;
+    hearing: boolean;
+    ducked: boolean;
+    muted: boolean;
+    /** 口语课热身:刚放完 [[echo]] / [[say]] 那句,那张卡亮着「轮到你」 */
+    turn: boolean;
+}
+/**
+ * 孩子做的:press 按满 150 毫秒 · release 松手 · cancel 上滑松手 · cardTap 点卡上的声音 · send 打字发出、交答案、发照片 ·
+ * stage 开 / 关舞台、拿起相机;
+ * 声音的:audio 嘴的一块声音到了 · drained 孩子端的队列放完了(play:刚念完的那句 [[play]] 到小课堂卡,open = 能放、skip = 课包读不出来;
+ * echo:刚念完的是热身的 [[echo]] / [[say]];call:刚念完的是 [[call]])· cardEnded 卡的声音念完 / 停了 · lectureDone 小课堂那一段放完 / 孩子关了 · ringEnd 铃响够了;
+ * 服务端的:flush 清播放队列 · cards 卡铺上来、老师写完 · drop 连不上 / 断了;页面的:reset 换老师、关老师页;
+ * 一直听:listen 进老师页时开或关(口语课、live.listen) · mute / unmute 点麦克风胶囊 · vad 服务端说孩子开口 / 说完 · duck / unduck 服务端让嘴的声音压低 / 恢复;
+ * 重放:replay 点「再听一遍」(pending = 脑在写,不放)· replayStop 点「停」· replayEnded 放完了
+ */
+export type LiveEvent = {
+    type: 'press';
+} | {
+    type: 'release';
+} | {
+    type: 'cancel';
+} | {
+    type: 'audio';
+} | {
+    type: 'drained';
+    play?: 'open' | 'skip';
+    echo?: true;
+    call?: true;
+} | {
+    type: 'lectureDone';
+} | {
+    type: 'ringEnd';
+} | {
+    type: 'flush';
+} | {
+    type: 'cardTap';
+} | {
+    type: 'cardEnded';
+} | {
+    type: 'send';
+} | {
+    type: 'cards';
+} | {
+    type: 'stage';
+} | {
+    type: 'drop';
+} | {
+    type: 'reset';
+} | {
+    type: 'listen';
+    open: boolean;
+} | {
+    type: 'mute';
+} | {
+    type: 'unmute';
+} | {
+    type: 'vad';
+    on: boolean;
+} | {
+    type: 'duck';
+} | {
+    type: 'unduck';
+} | {
+    type: 'replay';
+    pending?: boolean;
+} | {
+    type: 'replayStop';
+} | {
+    type: 'replayEnded';
+};
+/**
+ * 要做的事,按顺序执行。hold / release / hush / send = 告诉服务端(send 的 body 页面带上);enqueue = 放刚到的这块嘴的声音(没有就丢掉);
+ * flush = 清掉孩子端没放的嘴的声音;stopCard / playCard = 停 / 念卡上的声音;openLecture / stopLecture = 铺满放 / 停下小课堂那一段(舞台停在那一帧);
+ * staged = 告诉服务端那一段放完了(后面的讲稿接着交给嘴);retry = 连不上、断了:回到「正在叫老师」,过一会儿再连(不回板书);render = 重画字幕与头像;
+ * 一直听:listen = 告诉服务端换了模式;gate = 告诉服务端推 / 不推了(on);duck / unduck = 嘴的声音压到三成 / 恢复;
+ * 口语课:ring / stopRing = 响铃 / 铃停(卡亮不亮看 turn,随 render 画);重放:playReplay / stopReplay = 从这一轮第一句放 / 停(页面取服务端留的那份声音)
+ */
+export type LiveEffect = {
+    kind: 'hold';
+} | {
+    kind: 'release';
+} | {
+    kind: 'hush';
+} | {
+    kind: 'send';
+} | {
+    kind: 'enqueue';
+} | {
+    kind: 'flush';
+} | {
+    kind: 'stopCard';
+} | {
+    kind: 'playCard';
+} | {
+    kind: 'openLecture';
+} | {
+    kind: 'stopLecture';
+} | {
+    kind: 'staged';
+} | {
+    kind: 'retry';
+} | {
+    kind: 'render';
+} | {
+    kind: 'listen';
+} | {
+    kind: 'gate';
+    on: boolean;
+} | {
+    kind: 'duck';
+} | {
+    kind: 'unduck';
+} | {
+    kind: 'ring';
+} | {
+    kind: 'stopRing';
+} | {
+    kind: 'playReplay';
+} | {
+    kind: 'stopReplay';
+};
+export declare function initialLive(): LiveModel;
+/** 一直听时推不推孩子的声音:没关麦,卡没在念、小课堂没在放、没在响铃、没在重放(这些时候进麦的不是对老师说的;重放的是嘴从前说的,服务端比字比不到) */
+export declare function liveGate(m: LiveModel): boolean;
+export declare function liveStep(model: LiveModel, ev: LiveEvent): {
+    model: LiveModel;
+    effects: LiveEffect[];
+};

package/dist/runtime/delivery/player.js

@@ -0,0 +1,221 @@
+/**
+ * 实时老师的孩子端:谁出声、谁停、谁让谁(见 tests/live-player.test.ts)。纯函数,页面只 dispatch、照单执行。
+ * 实时时孩子端不念讲稿(嘴照念,声音从 WebSocket 下来,src/runtime/live/call.ts);出声的只有嘴和卡自己的声音(朗读卡点读、单词卡)。
+ * 板上的节(铺、写完、撤掉)是另一个状态机 board/presentation.ts 的 step;这里只管声音。
+ * 改规则的顺序:先改 tests/live-player.test.ts 的预期 → 再改这里。
+ * 一直听(全双工):孩子不用按,服务端的 VAD 判开口 / 说完;推不推孩子的声音是状态的函数(liveGate),一变就告诉服务端 gate。
+ * 口语课:热身的 [[echo]] / [[say]] 那句放完,那张卡亮「轮到你」(turn);[[call]] 那句放完响铃(孩子端自己的声音),嘴一出声铃停。
+ * 字幕重放:字幕下「再听一遍」,孩子端放这一轮嘴照念过的声音(服务端按轮留的那份);只在安静、脑不在写时开始,不告诉服务端任何东西。
+ */
+export function initialLive() {
+    return { status: 'quiet', cut: false, open: false, hearing: false, ducked: false, muted: false, turn: false };
+}
+/** 一直听时推不推孩子的声音:没关麦,卡没在念、小课堂没在放、没在响铃、没在重放(这些时候进麦的不是对老师说的;重放的是嘴从前说的,服务端比字比不到) */
+export function liveGate(m) {
+    return m.open && !m.muted && m.status !== 'card' && m.status !== 'lecture' && m.status !== 'ring' && m.status !== 'replay' && m.status !== 'holding';
+}
+/** 停掉孩子端在出的声音:嘴的清掉、卡的停、小课堂那一段停下、铃停、重放停 */
+function hushLocal(m, fx) {
+    if (m.status === 'mouth')
+        fx.push({ kind: 'flush' });
+    if (m.status === 'card')
+        fx.push({ kind: 'stopCard' });
+    if (m.status === 'lecture')
+        fx.push({ kind: 'stopLecture' });
+    if (m.status === 'ring')
+        fx.push({ kind: 'stopRing' });
+    if (m.status === 'replay')
+        fx.push({ kind: 'stopReplay' });
+}
+export function liveStep(model, ev) {
+    const r = liveTransition(model, ev);
+    // 推不推变了就告诉服务端(一直听;关的时候孩子说到一半的那句作废)
+    if (liveGate(model) !== liveGate(r.model))
+        r.effects.push({ kind: 'gate', on: liveGate(r.model) });
+    return r;
+}
+/** 名字别和 board/presentation.ts 的 step 撞:两份都内联进孩子端页面 */
+function liveTransition(model, ev) {
+    const fx = [];
+    let m = model;
+    const to = (status, extra = {}) => { m = { ...m, status, ...extra }; };
+    switch (ev.type) {
+        case 'press':
+            // 一直听时那条是胶囊,不是按住说话
+            if (m.status === 'holding' || m.open)
+                break;
+            hushLocal(m, fx);
+            fx.push({ kind: 'hold' });
+            to('holding', { cut: m.status === 'mouth' });
+            break;
+        case 'release':
+            if (m.status !== 'holding')
+                break;
+            fx.push({ kind: 'release' });
+            to('quiet');
+            break;
+        case 'cancel':
+            if (m.status !== 'holding')
+                break;
+            fx.push({ kind: 'hush' });
+            to('quiet');
+            break;
+        case 'audio':
+            // 按着:按下前已经在路上的那几块丢掉
+            if (m.status === 'holding')
+                break;
+            if (m.status === 'card')
+                fx.push({ kind: 'stopCard' });
+            if (m.status === 'lecture')
+                fx.push({ kind: 'stopLecture' });
+            if (m.status === 'ring')
+                fx.push({ kind: 'stopRing' });
+            if (m.status === 'replay')
+                fx.push({ kind: 'stopReplay' });
+            fx.push({ kind: 'enqueue' });
+            if (m.status !== 'mouth') {
+                to('mouth', { cut: false, turn: false });
+                fx.push({ kind: 'render' });
+            }
+            break;
+        case 'drained':
+            if (m.status !== 'mouth')
+                break;
+            // [[play]]:那句念完了铺满放那一段;放不了就告诉服务端接着交。[[call]]:响铃。[[echo]] / [[say]]:安静,那张卡亮「轮到你」
+            if (ev.play === 'open') {
+                fx.push({ kind: 'openLecture' });
+                to('lecture');
+            }
+            else if (ev.call) {
+                fx.push({ kind: 'ring' });
+                to('ring');
+            }
+            else {
+                if (ev.play === 'skip')
+                    fx.push({ kind: 'staged' });
+                to('quiet', ev.echo ? { turn: true } : {});
+            }
+            fx.push({ kind: 'render' });
+            break;
+        case 'ringEnd':
+            if (m.status !== 'ring')
+                break;
+            to('quiet');
+            fx.push({ kind: 'render' });
+            break;
+        case 'lectureDone':
+            if (m.status !== 'lecture')
+                break;
+            fx.push({ kind: 'staged' });
+            to('quiet');
+            fx.push({ kind: 'render' });
+            break;
+        case 'flush':
+            fx.push({ kind: 'flush' });
+            if (m.ducked) {
+                fx.push({ kind: 'unduck' });
+                m = { ...m, ducked: false };
+            }
+            if (m.status === 'mouth' || m.turn) {
+                to(m.status === 'mouth' ? 'quiet' : m.status, { turn: false });
+                fx.push({ kind: 'render' });
+            }
+            break;
+        case 'cardTap':
+            if (m.status !== 'quiet' && m.status !== 'card' && m.status !== 'replay')
+                break;
+            if (m.status === 'replay')
+                fx.push({ kind: 'stopReplay' });
+            fx.push({ kind: 'playCard' });
+            to('card');
+            break;
+        case 'cardEnded':
+            if (m.status === 'card')
+                to('quiet');
+            break;
+        case 'send':
+            // 同说了一句:手还按着(两根手指)先把那一下作废
+            if (m.status === 'holding')
+                fx.push({ kind: 'hush' });
+            hushLocal(m, fx);
+            fx.push({ kind: 'send' });
+            to('quiet', { cut: m.status === 'mouth', turn: false });
+            fx.push({ kind: 'render' });
+            break;
+        case 'cards':
+        case 'stage':
+            break;
+        case 'drop':
+            fx.push({ kind: 'flush' }, { kind: 'stopCard' }, { kind: 'stopLecture' }, { kind: 'stopRing' }, { kind: 'stopReplay' }, { kind: 'retry' });
+            if (m.ducked)
+                fx.push({ kind: 'unduck' });
+            // 一直听是孩子选的说话方式,不是声音的状态:清了也留着
+            m = { ...initialLive(), open: m.open };
+            break;
+        case 'reset':
+            fx.push({ kind: 'flush' }, { kind: 'stopCard' }, { kind: 'stopLecture' }, { kind: 'stopRing' }, { kind: 'stopReplay' });
+            if (m.ducked)
+                fx.push({ kind: 'unduck' });
+            m = { ...initialLive(), open: m.open };
+            break;
+        case 'listen':
+            // 手还按着就换了模式:那一下作废
+            if (m.status === 'holding') {
+                fx.push({ kind: 'hush' });
+                to('quiet');
+            }
+            fx.push({ kind: 'listen' });
+            if (m.ducked)
+                fx.push({ kind: 'unduck' });
+            m = { ...m, open: ev.open, hearing: false, ducked: false, muted: false };
+            fx.push({ kind: 'render' });
+            break;
+        case 'mute':
+        case 'unmute':
+            if (!m.open || m.muted === (ev.type === 'mute'))
+                break;
+            m = { ...m, muted: ev.type === 'mute', hearing: false };
+            fx.push({ kind: 'render' });
+            break;
+        case 'vad':
+            if (!m.open || m.hearing === ev.on)
+                break;
+            m = { ...m, hearing: ev.on };
+            fx.push({ kind: 'render' });
+            break;
+        case 'duck':
+            if (m.ducked)
+                break;
+            m = { ...m, ducked: true };
+            fx.push({ kind: 'duck' });
+            break;
+        case 'unduck':
+            if (!m.ducked)
+                break;
+            m = { ...m, ducked: false };
+            fx.push({ kind: 'unduck' });
+            break;
+        case 'replay':
+            // 只在安静、脑不在写时放(那行字本来就只在这时露);不告诉服务端
+            if (m.status !== 'quiet' || ev.pending)
+                break;
+            fx.push({ kind: 'playReplay' });
+            to('replay');
+            fx.push({ kind: 'render' });
+            break;
+        case 'replayStop':
+            if (m.status !== 'replay')
+                break;
+            fx.push({ kind: 'stopReplay' });
+            to('quiet');
+            fx.push({ kind: 'render' });
+            break;
+        case 'replayEnded':
+            if (m.status !== 'replay')
+                break;
+            to('quiet');
+            fx.push({ kind: 'render' });
+            break;
+    }
+    return { model: m, effects: fx };
+}

package/dist/runtime/delivery/queue.d.ts

@@ -0,0 +1,89 @@
+/**
+ * 照念的排队:脑写完的讲稿一拍一拍进来,嘴一空就交给它。纯函数。
+ * 2026-10-19 改成流水线:原来等上一段声音放完再交,段与段之间静 1.3 秒;嘴出字比念快得多(一段字 1.9 秒出完、声音要放 11.6 秒),
+ * 现在嘴出完上一段就交下一段,声音在孩子端接着排,中间不空。排着的几拍一次交(同一轮的并成一段念)。
+ * 孩子按下 = 打断:排着的都丢,那一轮后面再来的拍也丢;孩子听到哪由调用方按声音排到哪算(src/runtime/delivery/playback.ts)。
+ * 讲稿的 [[play]](小课堂,P3.2):并段到那句为止;交出去以后关闸,孩子端放完那一段(staged)才交后面的。
+ * 一直听:孩子开口先 pause(不交新的、也不丢),判出这句是对老师说的才 hold(丢),放过就 release 接着交。
+ * 热身:讲稿的 [[echo 词]] / [[say 词]] 同 [[play]],并段到那句为止、交出去关闸,孩子跟完(或等够了)echoed 才交后面的;
+ * [[call]] 并段到那句为止、交出去关闸(孩子端响铃),铃响够了 rung 才交打电话那一轮的;那一轮后面再来的拍都不要(打电话那段由下一轮写)。
+ * 嘴卡住(交出去的那段一个字没出,2026-10-31):retry 放回排头、不交,调用方换好连接 done 了再交(和后来的同一轮的并成一段)。
+ */
+/** 热身那句要孩子说的:word = 记号里的词;say = 你先说(老师没说出这个词) */
+export interface Echo {
+    word: string;
+    say?: true;
+}
+/** 一拍的讲稿:哪一轮、讲稿第几句(0 起)、句子;play = 最后一句念完孩子端放小课堂那一段;echo = 最后一句念完等孩子跟;call = 最后一句念完进打电话 */
+export interface Beat {
+    job: string;
+    lines: number[];
+    texts: string[];
+    play?: boolean;
+    echo?: Echo;
+    call?: true;
+}
+export interface QueueState {
+    pending: Beat[];
+    /** 嘴有一次回答要了还没出完(接住或照念) */
+    busy: boolean;
+    holding: boolean;
+    /** 最近交进来的那一轮;打断时它后面再来的拍都丢 */
+    lastJob: string | null;
+    dropJob: string | null;
+    /** 交给嘴的那段最后一句要放小课堂(play:孩子端放完 staged 之前不交下一段)、要孩子跟(echo:孩子跟完 echoed 之前不交)、进打电话(call:铃响够了 rung 之前不交) */
+    gated: false | 'play' | 'echo' | 'call';
+    /** 念过 [[call]] 的那一轮:后面再来的拍都不要 */
+    closedJob: string | null;
+}
+export type QueueEvent = {
+    e: 'beat';
+    beat: Beat;
+}
+/** drop = 这一刻正在答的那一轮(调用方知道,它的拍可能还没来):打断后它的拍都丢 */
+ | {
+    e: 'hold';
+    drop?: string | null;
+}
+/** 一直听时孩子开口:还不知道是不是对老师说的,先不交新的、排着的不丢;release 接着交 */
+ | {
+    e: 'pause';
+} | {
+    e: 'release';
+}
+/** 调用方让嘴说了一句别的(接住):嘴出完之前不交讲稿 */
+ | {
+    e: 'asked';
+} | {
+    e: 'done';
+}
+/** 孩子端放完了小课堂那一段(或放不了、被关) */
+ | {
+    e: 'staged';
+}
+/** 孩子跟完了 [[echo]] / [[say]] 那句(或等够了没开口) */
+ | {
+    e: 'echoed';
+}
+/** [[call]] 那句放完、铃响够了 */
+ | {
+    e: 'rung';
+}
+/** 交给嘴的那段一个字都没出就卡住了:放回排头(打断过的那一轮不放),闸也开了;这时来的拍也不交,等调用方换好连接 done */
+ | {
+    e: 'retry';
+    beat: Beat;
+};
+/** read = 把这几句交给嘴;dropped = 按下时还排着没交的(调用方算孩子听到哪) */
+export type QueueAction = {
+    kind: 'read';
+    beat: Beat;
+} | {
+    kind: 'dropped';
+    beats: Beat[];
+} | null;
+export declare const queueInit: () => QueueState;
+export declare function queueStep(s: QueueState, ev: QueueEvent): {
+    s: QueueState;
+    act: QueueAction;
+};

package/dist/runtime/delivery/queue.js

@@ -0,0 +1,59 @@
+/**
+ * 照念的排队:脑写完的讲稿一拍一拍进来,嘴一空就交给它。纯函数。
+ * 2026-10-19 改成流水线:原来等上一段声音放完再交,段与段之间静 1.3 秒;嘴出字比念快得多(一段字 1.9 秒出完、声音要放 11.6 秒),
+ * 现在嘴出完上一段就交下一段,声音在孩子端接着排,中间不空。排着的几拍一次交(同一轮的并成一段念)。
+ * 孩子按下 = 打断:排着的都丢,那一轮后面再来的拍也丢;孩子听到哪由调用方按声音排到哪算(src/runtime/delivery/playback.ts)。
+ * 讲稿的 [[play]](小课堂,P3.2):并段到那句为止;交出去以后关闸,孩子端放完那一段(staged)才交后面的。
+ * 一直听:孩子开口先 pause(不交新的、也不丢),判出这句是对老师说的才 hold(丢),放过就 release 接着交。
+ * 热身:讲稿的 [[echo 词]] / [[say 词]] 同 [[play]],并段到那句为止、交出去关闸,孩子跟完(或等够了)echoed 才交后面的;
+ * [[call]] 并段到那句为止、交出去关闸(孩子端响铃),铃响够了 rung 才交打电话那一轮的;那一轮后面再来的拍都不要(打电话那段由下一轮写)。
+ * 嘴卡住(交出去的那段一个字没出,2026-10-31):retry 放回排头、不交,调用方换好连接 done 了再交(和后来的同一轮的并成一段)。
+ */
+export const queueInit = () => ({ pending: [], busy: false, holding: false, lastJob: null, dropJob: null, gated: false, closedJob: null });
+/** 这拍念完要停下来等的(小课堂、孩子跟)或这一轮到此为止的(打电话) */
+const stops = (b) => Boolean(b.play || b.echo || b.call);
+function drain(s) {
+    if (s.holding || s.busy || s.gated || !s.pending.length)
+        return { s, act: null };
+    const job = s.pending[0].job;
+    const take = [];
+    for (const b of s.pending) {
+        if (b.job !== job)
+            continue;
+        take.push(b);
+        if (stops(b))
+            break;
+    }
+    const last = take[take.length - 1];
+    const beat = { job, lines: take.flatMap((b) => b.lines), texts: take.flatMap((b) => b.texts), ...(last.play ? { play: true } : {}), ...(last.echo ? { echo: last.echo } : {}), ...(last.call ? { call: true } : {}) };
+    // [[call]]:那一轮排着的、后面再来的都不要
+    const pending = s.pending.filter((b) => !take.includes(b) && !(last.call && b.job === job));
+    return { s: { ...s, pending, busy: true, gated: last.play ? 'play' : last.echo ? 'echo' : last.call ? 'call' : false, ...(last.call ? { closedJob: job } : {}) }, act: { kind: 'read', beat } };
+}
+export function queueStep(s, ev) {
+    switch (ev.e) {
+        case 'beat':
+            if (ev.beat.job === s.dropJob || ev.beat.job === s.closedJob || !ev.beat.texts.some((x) => x.trim()))
+                return { s, act: null };
+            return drain({ ...s, pending: [...s.pending, ev.beat], lastJob: ev.beat.job });
+        case 'hold':
+            return { s: { ...s, holding: true, pending: [], gated: false, dropJob: ev.drop ?? s.lastJob }, act: s.pending.length ? { kind: 'dropped', beats: s.pending } : null };
+        case 'pause':
+            return { s: { ...s, holding: true }, act: null };
+        case 'release':
+            return drain({ ...s, holding: false });
+        case 'asked':
+            return { s: { ...s, busy: true }, act: null };
+        case 'done':
+            return drain({ ...s, busy: false });
+        // 各开各的闸:小课堂放完开不了等孩子跟的闸,反过来也一样;没关闸时照常交
+        case 'staged':
+            return s.gated && s.gated !== 'play' ? { s, act: null } : drain({ ...s, gated: false });
+        case 'echoed':
+            return s.gated && s.gated !== 'echo' ? { s, act: null } : drain({ ...s, gated: false });
+        case 'rung':
+            return s.gated && s.gated !== 'call' ? { s, act: null } : drain({ ...s, gated: false });
+        case 'retry':
+            return { s: { ...s, busy: true, gated: false, ...(ev.beat.job === s.dropJob ? {} : { pending: [ev.beat, ...s.pending] }) }, act: null };
+    }
+}

package/dist/runtime/home/edit.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 家长端「首页」表单改首页:不另存一份结构,直接改已发布那份的原文(home/history/<id>.md),
+ * 改完照常检查、留历史、发布。这里是纯函数:把 md 切成围栏块,按老师改按钮、改听写的词、调老师的先后,再拼回去。
+ * 没动到的块(别的老师、家长自己写的卡、家长段)原样留着,一个字不改。
+ */
+import type { TutorButton } from '../../board/cards/index.ts';
+/** 一个围栏块(卡)或一段围栏外的字 */
+export type HomeSeg = {
+    kind: 'fence';
+    fence: string;
+    card: string;
+    mods: string[];
+    info: string;
+    body: string[];
+} | {
+    kind: 'text';
+    lines: string[];
+};
+export interface HomeParts {
+    /** frontmatter(含上下两行 ---);没有 = [] */
+    front: string[];
+    segs: HomeSeg[];
+    /** 家长段:第一个围栏外的 H2 起到末尾 */
+    note: string[];
+}
+export declare function splitHomeMd(md: string): HomeParts;
+export declare function joinHomeMd(p: HomeParts): string;
+/** 老师卡的正文:一行一个按钮,讲法与留到挂在下面 */
+export declare function tutorBody(buttons: readonly TutorButton[]): string[];
+/** 换掉这位老师的按钮(整张卡的正文);没有老师卡就加一张 */
+export declare function setTutorButtons(md: string, name: string, buttons: readonly TutorButton[]): string;
+/** 这位老师的听写卡(`dictation <老师>`):words 空 = 删掉;没有就紧跟在他的老师卡后面加一张 */
+export declare function setTutorDictation(md: string, name: string, words: readonly {
+    chars: string;
+    say?: string;
+    emoji?: string;
+}[]): string;
+/** 调老师的先后:names 里的按这个顺序排(没有老师卡的补一张空的),别的老师照原来的相对顺序排在后面;每位老师带着跟在他后面的卡一起挪 */
+export declare function orderTutors(md: string, names: readonly string[]): string;