cotutor 0.1.0 → 0.3.0

package/dist/chalk/clock.js

@@ -0,0 +1,84 @@
+/**
+ * 一堂课的时钟(纯函数,浏览器外可用):课包的每一步首尾相接成一条时间线,像视频一样能问「第 t 毫秒是什么样」。
+ * ChalkPlayer 是接力式(一步画完停在气口);这里不停气口——停不停是播放器的事,时钟只管时间。
+ *
+ * 一段 = 一步,段长 = max(这步画多久, 这步配音多久):画完了定格、声音接着讲;声音先完,等画完。
+ * 课的 0 毫秒对着 SVG 时间线的 START_MS(开头那一秒空白不算进课里)。笔画按配音拉伸(stretchToAudio,只拉不缩、封顶 5 倍)。
+ * 笔顺里的动作(擦掉、换画板,core/actions.ts)和画一笔一样占时间;被擦的元素记下擦它的那段时间,擦完就不在画面上了。
+ */
+import { resolveActions } from "./actions.js";
+import { durationOf, FREEZE_EPS_MS, START_MS, stretchToAudio } from "./timeline.js";
+/**
+ * 课包 → 时钟。steps 的 elementIds 应按顺序覆盖全部元素(场景的约定,check 把关);
+ * 这里不抛:没对上的元素照样排进 SVG 时间线,只是不属于任何一步。durations 同 stretchToAudio(播放器探测到的配音时长)。
+ */
+export function lessonClock(skeletons, steps, opts = {}) {
+    const stretched = stretchToAudio(skeletons, steps, opts).skeletons;
+    const stepOf = new Map();
+    steps.forEach((s, i) => s.elementIds.forEach((id) => stepOf.set(id, i)));
+    const acts = resolveActions(stretched);
+    const elements = new Map();
+    const boardSwitches = [];
+    let cur = START_MS;
+    for (const e of stretched) {
+        const start = cur;
+        cur += durationOf(e);
+        elements.set(e.id, { start, end: cur, step: stepOf.get(e.id) ?? -1, board: acts.boardOf.get(e.id) ?? 0 });
+        if (e.type === 'board')
+            boardSwitches.push(cur);
+    }
+    for (const [id, by] of acts.erasedBy) {
+        const w = elements.get(id);
+        const a = elements.get(by);
+        if (w && a)
+            w.erased = { start: a.start, end: a.end };
+    }
+    const segments = [];
+    let prevDraw = START_MS;
+    let at = 0;
+    steps.forEach((s, i) => {
+        const last = s.elementIds[s.elementIds.length - 1];
+        const drawEnd = last !== undefined ? (elements.get(last)?.end ?? prevDraw) : prevDraw;
+        const audioMs = opts.durations?.[i] ?? s.audioDurationMs ?? null;
+        const len = Math.max(drawEnd - prevDraw, audioMs ?? 0, 1);
+        segments.push({ index: i, start: at, len, drawStart: prevDraw, drawEnd, audioMs, line: s.line, ...(s.audioSrc ? { audioSrc: s.audioSrc } : {}) });
+        at += len;
+        prevDraw = drawEnd;
+    });
+    return { skeletons: stretched, segments, total: at, elements, boardSwitches };
+}
+/** 课里的某一刻 → 第几段、段内多少、SVG 该停在哪(毫秒;画完了定格在窗终点前半毫秒)。越界夹到 0..total;没有步 index = -1 */
+export function clockAt(clock, ms) {
+    const t = Math.max(0, Math.min(ms, clock.total));
+    const segs = clock.segments;
+    if (!segs.length)
+        return { index: -1, offset: 0, svgMs: START_MS };
+    let i = segs.findIndex((s) => t < s.start + s.len);
+    if (i < 0)
+        i = segs.length - 1;
+    const s = segs[i];
+    const offset = t - s.start;
+    return { index: i, offset, svgMs: Math.min(s.drawStart + offset, s.drawEnd - FREEZE_EPS_MS) };
+}
+export function frameAt(clock, ms) {
+    const at = clockAt(clock, ms);
+    return { index: at.index, line: clock.segments[at.index]?.line ?? '', svgMs: at.svgMs, board: boardAtSvgTime(clock, at.svgMs), elements: elementsAtSvgTime(clock, at.svgMs) };
+}
+/** SVG 时间线上的某一刻在第几块画板 */
+export function boardAtSvgTime(clock, svgMs) {
+    return (clock.boardSwitches ?? []).filter((t) => t <= svgMs).length;
+}
+/** SVG 时间线上的某一刻(毫秒,含 START_MS)画面上有哪些元素、各画了多少:存的是 SVG 时刻的(圈的卡的缩略图)直接用它 */
+export function elementsAtSvgTime(clock, svgMs) {
+    const out = [];
+    for (const [id, w] of clock.elements) {
+        if (w.start >= svgMs)
+            continue;
+        if (w.erased && w.erased.end <= svgMs)
+            continue;
+        const progress = w.end <= w.start ? 1 : Math.min(1, (svgMs - w.start) / (w.end - w.start));
+        const e = w.erased;
+        out.push(e && e.start < svgMs ? { id, progress, fade: 1 - (svgMs - e.start) / (e.end - e.start) } : { id, progress });
+    }
+    return out;
+}

package/dist/chalk/geometry.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 元素的几何(纯函数,浏览器外可用):包围盒、取样点。
+ * 文字宽按 text-metrics(用真播放器量的手写字体字宽);线按点;框、椭圆、菱形按宽高。
+ * 手绘抖动、线宽不算进包围盒(差一两个像素,圈与布局都不在乎)。
+ */
+import type { ChalkSkeleton } from './types.ts';
+/** 场景坐标的包围盒 */
+export interface Bounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+/** 课包里存的样子(scene.json 的 bounds):[minX, minY, maxX, maxY] */
+export type BoundsTuple = [number, number, number, number];
+/** 一个字有多宽(字号 1):表里有用表里的;CJK 表意文字、全角符号按 CJK_EM;其余按 FALLBACK_EM */
+export declare function charEm(ch: string): number;
+/** 一段字(可多行)在这个字号下的宽高 */
+export declare function measureText(text: string, fontSize: number): {
+    width: number;
+    height: number;
+};
+/** 线、箭头、自由笔画的点(场景坐标);不是这几种 = null */
+export declare function pointsOf(el: ChalkSkeleton): [number, number][] | null;
+/**
+ * 元素的包围盒。文字:元素自带比估的宽的 width(生成器、编辑器量过)以它为准,否则按字宽表算;
+ * 有点的按点;其余按 x/y/width/height。
+ */
+export declare function elementBounds(el: ChalkSkeleton): Bounds;
+/** build 落进 scene.json 的 bounds:每个元素一个,保留一位小数 */
+export declare function sceneBounds(skeletons: readonly ChalkSkeleton[]): Record<string, BoundsTuple>;
+/** 一组包围盒的并;空 = null */
+export declare function unionBounds(bs: readonly Bounds[]): Bounds | null;
+/** 两个盒子之间的距离(重叠 = 0) */
+export declare function boundsGap(a: Bounds, b: Bounds): number;
+/**
+ * 元素上的取样点(圈住了没有,看有多少样点落在圈里):文字取包围盒里的九宫格;线取沿线的点;
+ * 框、椭圆、菱形只取边上的点——圈在框里面的东西,不算圈住了框。
+ */
+export declare function samplePoints(el: ChalkSkeleton, bounds?: Bounds): [number, number][];
+/** 点在不在多边形里(首尾连上;射线法) */
+export declare function insidePolygon(poly: readonly [number, number][], [x, y]: readonly [number, number]): boolean;
+/** 一串点的包围盒(圈的大小、位置) */
+export declare function boundsOfPoints(pts: readonly [number, number][]): Bounds;

package/dist/chalk/geometry.js

@@ -0,0 +1,139 @@
+/**
+ * 元素的几何(纯函数,浏览器外可用):包围盒、取样点。
+ * 文字宽按 text-metrics(用真播放器量的手写字体字宽);线按点;框、椭圆、菱形按宽高。
+ * 手绘抖动、线宽不算进包围盒(差一两个像素,圈与布局都不在乎)。
+ */
+import { isAction } from "./actions.js";
+import { CHAR_EM, CJK_EM, FALLBACK_EM, LINE_HEIGHT } from "./text-metrics.js";
+const num = (v, d = 0) => (typeof v === 'number' && Number.isFinite(v) ? v : d);
+/** 一个字有多宽(字号 1):表里有用表里的;CJK 表意文字、全角符号按 CJK_EM;其余按 FALLBACK_EM */
+export function charEm(ch) {
+    const w = CHAR_EM[ch];
+    if (w !== undefined)
+        return w;
+    const cp = ch.codePointAt(0) ?? 0;
+    return cp >= 0x2e80 ? CJK_EM : FALLBACK_EM;
+}
+/** 一段字(可多行)在这个字号下的宽高 */
+export function measureText(text, fontSize) {
+    const rows = text.split('\n');
+    const width = Math.max(0, ...rows.map((r) => [...r].reduce((a, ch) => a + charEm(ch), 0))) * fontSize;
+    return { width, height: rows.length * fontSize * LINE_HEIGHT };
+}
+/** 线、箭头、自由笔画的点(场景坐标);不是这几种 = null */
+export function pointsOf(el) {
+    if (!Array.isArray(el.points))
+        return null;
+    return el.points
+        .filter((p) => Array.isArray(p) && p.length >= 2 && typeof p[0] === 'number' && typeof p[1] === 'number')
+        .map((p) => [num(el.x) + p[0], num(el.y) + p[1]]);
+}
+function boxOfPoints(pts) {
+    return { minX: Math.min(...pts.map((p) => p[0])), minY: Math.min(...pts.map((p) => p[1])), maxX: Math.max(...pts.map((p) => p[0])), maxY: Math.max(...pts.map((p) => p[1])) };
+}
+/**
+ * 元素的包围盒。文字:元素自带比估的宽的 width(生成器、编辑器量过)以它为准,否则按字宽表算;
+ * 有点的按点;其余按 x/y/width/height。
+ */
+export function elementBounds(el) {
+    const x = num(el.x);
+    const y = num(el.y);
+    if (el.type === 'text') {
+        const m = measureText(String(el.text ?? ''), num(el.fontSize, 20));
+        const w = typeof el.width === 'number' && el.width > m.width ? el.width : m.width;
+        const h = typeof el.height === 'number' && el.height > m.height ? el.height : m.height;
+        return { minX: x, minY: y, maxX: x + w, maxY: y + h };
+    }
+    const pts = pointsOf(el);
+    if (pts && pts.length)
+        return boxOfPoints(pts);
+    return { minX: x, minY: y, maxX: x + num(el.width), maxY: y + num(el.height) };
+}
+/** build 落进 scene.json 的 bounds:每个元素一个,保留一位小数 */
+export function sceneBounds(skeletons) {
+    const r = (n) => Math.round(n * 10) / 10;
+    const out = {};
+    for (const el of skeletons) {
+        if (isAction(el))
+            continue; // 动作不画东西,没有包围盒
+        const b = elementBounds(el);
+        out[el.id] = [r(b.minX), r(b.minY), r(b.maxX), r(b.maxY)];
+    }
+    return out;
+}
+/** 一组包围盒的并;空 = null */
+export function unionBounds(bs) {
+    if (!bs.length)
+        return null;
+    return { minX: Math.min(...bs.map((b) => b.minX)), minY: Math.min(...bs.map((b) => b.minY)), maxX: Math.max(...bs.map((b) => b.maxX)), maxY: Math.max(...bs.map((b) => b.maxY)) };
+}
+/** 两个盒子之间的距离(重叠 = 0) */
+export function boundsGap(a, b) {
+    return Math.hypot(Math.max(0, a.minX - b.maxX, b.minX - a.maxX), Math.max(0, a.minY - b.maxY, b.minY - a.maxY));
+}
+/**
+ * 元素上的取样点(圈住了没有,看有多少样点落在圈里):文字取包围盒里的九宫格;线取沿线的点;
+ * 框、椭圆、菱形只取边上的点——圈在框里面的东西,不算圈住了框。
+ */
+export function samplePoints(el, bounds = elementBounds(el)) {
+    if (el.type === 'text') {
+        const out = [];
+        for (const fx of [0.2, 0.5, 0.8])
+            for (const fy of [0.25, 0.5, 0.75])
+                out.push([bounds.minX + (bounds.maxX - bounds.minX) * fx, bounds.minY + (bounds.maxY - bounds.minY) * fy]);
+        return out;
+    }
+    const pts = pointsOf(el);
+    if (pts && pts.length) {
+        if (pts.length === 1)
+            return pts;
+        const out = [];
+        const per = Math.max(2, Math.ceil(12 / (pts.length - 1)));
+        for (let i = 1; i < pts.length; i++) {
+            for (let k = 0; k <= per; k++) {
+                if (i > 1 && k === 0)
+                    continue;
+                const t = k / per;
+                out.push([pts[i - 1][0] + (pts[i][0] - pts[i - 1][0]) * t, pts[i - 1][1] + (pts[i][1] - pts[i - 1][1]) * t]);
+            }
+        }
+        return out;
+    }
+    const { minX: x, minY: y } = bounds;
+    const w = bounds.maxX - bounds.minX;
+    const h = bounds.maxY - bounds.minY;
+    const out = [];
+    for (let k = 0; k < 16; k++) {
+        const a = (k / 16) * Math.PI * 2;
+        if (el.type === 'ellipse')
+            out.push([x + w / 2 + (w / 2) * Math.cos(a), y + h / 2 + (h / 2) * Math.sin(a)]);
+        else if (el.type === 'diamond') {
+            const c = Math.cos(a);
+            const s = Math.sin(a);
+            const k1 = 1 / (Math.abs(c) + Math.abs(s));
+            out.push([x + w / 2 + (w / 2) * c * k1, y + h / 2 + (h / 2) * s * k1]);
+        }
+        else {
+            const t = (k / 16) * 4;
+            const side = Math.floor(t);
+            const f = t - side;
+            out.push(side === 0 ? [x + w * f, y] : side === 1 ? [x + w, y + h * f] : side === 2 ? [x + w * (1 - f), y + h] : [x, y + h * (1 - f)]);
+        }
+    }
+    return out;
+}
+/** 点在不在多边形里(首尾连上;射线法) */
+export function insidePolygon(poly, [x, y]) {
+    let hit = false;
+    for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+        const [xi, yi] = poly[i];
+        const [xj, yj] = poly[j];
+        if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi)
+            hit = !hit;
+    }
+    return hit;
+}
+/** 一串点的包围盒(圈的大小、位置) */
+export function boundsOfPoints(pts) {
+    return boxOfPoints(pts);
+}

package/dist/chalk/glyphs/capitals.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 26 个大写拉丁字母的笔顺(print 分写体,英美小学通行写法)。小写在 letters.ts。
+ *
+ * 顶到 CAP(= 升部顶,四线三格的第一线),坐在基线上;只有 Q 的尾巴探出基线。
+ * 笔顺遵教学通行序:先竖后横(E F H L T)、先左后右(A M N V W)、圈类逆时针(C G O Q S)。
+ * 宽度参考 Excalifont 实测比例后规整化——手写体的字宽起伏属于骨架,不跟。
+ *
+ * 改动请重跑 `pnpm test` 与 `scripts/glyph-sheet.mjs --caps`。
+ */
+import type { Glyph } from './types.ts';
+/** A–Z → 字形 */
+export declare const UPPERCASE: ReadonlyMap<string, Glyph>;

package/dist/chalk/glyphs/capitals.js

@@ -0,0 +1,264 @@
+/**
+ * 26 个大写拉丁字母的笔顺(print 分写体,英美小学通行写法)。小写在 letters.ts。
+ *
+ * 顶到 CAP(= 升部顶,四线三格的第一线),坐在基线上;只有 Q 的尾巴探出基线。
+ * 笔顺遵教学通行序:先竖后横(E F H L T)、先左后右(A M N V W)、圈类逆时针(C G O Q S)。
+ * 宽度参考 Excalifont 实测比例后规整化——手写体的字宽起伏属于骨架,不跟。
+ *
+ * 改动请重跑 `pnpm test` 与 `scripts/glyph-sheet.mjs --caps`。
+ */
+import { CAP, XT, BASE } from "./metrics.js";
+/** 大写的中腰:H 的横、E 的中横、A 的横都落在这一带 */
+const MID = XT;
+const CAPITALS = [
+    {
+        ch: 'A',
+        advance: 1.5,
+        strokes: [
+            { start: [0.75, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            { start: [0.75, CAP], segs: [{ k: 'L', to: [1.5, BASE] }] },
+            // 横落在两斜边上(y = -0.72 处两边的交点)
+            { start: [0.27, -0.72], segs: [{ k: 'L', to: [1.23, -0.72] }] },
+        ],
+    },
+    {
+        ch: 'B',
+        advance: 1.35,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            // 上碗小、下碗大,print B 的常规比例
+            { start: [0, CAP], segs: [{ k: 'A', cx: 0, cy: -1.525, rx: 1.15, ry: 0.475, a0: -90, a1: 90 }] },
+            { start: [0, -1.05], segs: [{ k: 'A', cx: 0, cy: -0.525, rx: 1.35, ry: 0.525, a0: -90, a1: 90 }] },
+        ],
+    },
+    {
+        ch: 'C',
+        advance: 1.4,
+        strokes: [
+            { start: [0.85 + 0.85 * Math.cos((-50 * Math.PI) / 180), -1 + 1 * Math.sin((-50 * Math.PI) / 180)],
+                segs: [{ k: 'A', cx: 0.85, cy: -1, rx: 0.85, ry: 1, a0: -50, a1: -310 }] },
+        ],
+    },
+    {
+        ch: 'D',
+        advance: 1.5,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            { start: [0, CAP], segs: [{ k: 'A', cx: 0, cy: -1, rx: 1.5, ry: 1, a0: -90, a1: 90 }] },
+        ],
+    },
+    {
+        ch: 'E',
+        advance: 1.25,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            { start: [0, CAP], segs: [{ k: 'L', to: [1.25, CAP] }] },
+            // 中横略短,print E 的常规处理
+            { start: [0, MID], segs: [{ k: 'L', to: [1.05, MID] }] },
+            { start: [0, BASE], segs: [{ k: 'L', to: [1.25, BASE] }] },
+        ],
+    },
+    {
+        ch: 'F',
+        advance: 1.2,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            { start: [0, CAP], segs: [{ k: 'L', to: [1.2, CAP] }] },
+            { start: [0, MID], segs: [{ k: 'L', to: [1, MID] }] },
+        ],
+    },
+    {
+        ch: 'G',
+        advance: 1.45,
+        strokes: [
+            // C 形弧收在右下后,向上一小竖再向左一横——print G 的钩
+            { start: [0.775 + 0.775 * Math.cos((-40 * Math.PI) / 180), -1 + 1 * Math.sin((-40 * Math.PI) / 180)],
+                segs: [
+                    { k: 'A', cx: 0.775, cy: -1, rx: 0.775, ry: 1, a0: -40, a1: -330 },
+                    { k: 'L', to: [1.446, MID] },
+                    { k: 'L', to: [0.85, MID] },
+                ] },
+        ],
+    },
+    {
+        ch: 'H',
+        advance: 1.3,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            { start: [1.3, CAP], segs: [{ k: 'L', to: [1.3, BASE] }] },
+            { start: [0, MID], segs: [{ k: 'L', to: [1.3, MID] }] },
+        ],
+    },
+    {
+        ch: 'I',
+        advance: 1,
+        strokes: [
+            // 带上下横:和小写 l 拉开距离,教学体的常规选择
+            { start: [0.5, CAP], segs: [{ k: 'L', to: [0.5, BASE] }] },
+            { start: [0, CAP], segs: [{ k: 'L', to: [1, CAP] }] },
+            { start: [0, BASE], segs: [{ k: 'L', to: [1, BASE] }] },
+        ],
+    },
+    {
+        ch: 'J',
+        advance: 1,
+        strokes: [
+            { start: [1, CAP], segs: [
+                    { k: 'L', to: [1, -0.5] },
+                    { k: 'A', cx: 0.3, cy: -0.5, rx: 0.7, ry: 0.5, a0: 0, a1: 110 },
+                ] },
+        ],
+    },
+    {
+        ch: 'K',
+        advance: 1.35,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            // 一笔进出,与小写 k 同一套写法
+            { start: [1.35, CAP], segs: [
+                    { k: 'L', to: [0.05, -0.85] },
+                    { k: 'L', to: [1.35, BASE] },
+                ] },
+        ],
+    },
+    {
+        ch: 'L',
+        advance: 1.15,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            { start: [0, BASE], segs: [{ k: 'L', to: [1.15, BASE] }] },
+        ],
+    },
+    {
+        ch: 'M',
+        advance: 1.75,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            { start: [0, CAP], segs: [{ k: 'L', to: [0.875, -0.85] }] },
+            { start: [0.875, -0.85], segs: [{ k: 'L', to: [1.75, CAP] }] },
+            { start: [1.75, CAP], segs: [{ k: 'L', to: [1.75, BASE] }] },
+        ],
+    },
+    {
+        ch: 'N',
+        advance: 1.4,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            { start: [0, CAP], segs: [{ k: 'L', to: [1.4, BASE] }] },
+            { start: [1.4, CAP], segs: [{ k: 'L', to: [1.4, BASE] }] },
+        ],
+    },
+    {
+        ch: 'O',
+        advance: 1.6,
+        strokes: [
+            { start: [0.8, CAP], segs: [{ k: 'A', cx: 0.8, cy: -1, rx: 0.8, ry: 1, a0: -90, a1: -450 }] },
+        ],
+    },
+    {
+        ch: 'P',
+        advance: 1.3,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            { start: [0, CAP], segs: [{ k: 'A', cx: 0, cy: -1.475, rx: 1.3, ry: 0.525, a0: -90, a1: 90 }] },
+        ],
+    },
+    {
+        ch: 'Q',
+        advance: 1.7,
+        strokes: [
+            { start: [0.8, CAP], segs: [{ k: 'A', cx: 0.8, cy: -1, rx: 0.8, ry: 1, a0: -90, a1: -450 }] },
+            // 唯一探出基线的大写
+            { start: [1, -0.45], segs: [{ k: 'L', to: [1.7, 0.25] }] },
+        ],
+    },
+    {
+        ch: 'R',
+        advance: 1.35,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+            { start: [0, CAP], segs: [{ k: 'A', cx: 0, cy: -1.475, rx: 1.15, ry: 0.525, a0: -90, a1: 90 }] },
+            { start: [0.55, -0.95], segs: [{ k: 'L', to: [1.35, BASE] }] },
+        ],
+    },
+    {
+        ch: 'S',
+        advance: 1.3,
+        strokes: [
+            // 控制点 y 由 B(0.5)=0.125·P0+0.75·v+0.125·P3 反算,让上下弧正好触到大写线与基线
+            { start: [1.1, -1.62], segs: [
+                    { k: 'C', c1: [0.92, -2.143], c2: [0.28, -2.143], to: [0.18, -1.52] },
+                    { k: 'C', c1: [0.04, -0.98], c2: [1.24, -1.08], to: [1.12, -0.44] },
+                    { k: 'C', c1: [1.0, 0.117], c2: [0.36, 0.117], to: [0.15, -0.26] },
+                ] },
+        ],
+    },
+    {
+        ch: 'T',
+        advance: 1.5,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [1.5, CAP] }] },
+            { start: [0.75, CAP], segs: [{ k: 'L', to: [0.75, BASE] }] },
+        ],
+    },
+    {
+        ch: 'U',
+        advance: 1.4,
+        strokes: [
+            { start: [0, CAP], segs: [
+                    { k: 'L', to: [0, -0.55] },
+                    { k: 'A', cx: 0.7, cy: -0.55, rx: 0.7, ry: 0.55, a0: 180, a1: 0 },
+                    { k: 'L', to: [1.4, CAP] },
+                ] },
+        ],
+    },
+    {
+        ch: 'V',
+        advance: 1.45,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0.725, BASE] }, { k: 'L', to: [1.45, CAP] }] },
+        ],
+    },
+    {
+        ch: 'W',
+        advance: 2,
+        strokes: [
+            { start: [0, CAP], segs: [
+                    { k: 'L', to: [0.5, BASE] },
+                    { k: 'L', to: [1, -1.55] },
+                    { k: 'L', to: [1.5, BASE] },
+                    { k: 'L', to: [2, CAP] },
+                ] },
+        ],
+    },
+    {
+        ch: 'X',
+        advance: 1.4,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [1.4, BASE] }] },
+            { start: [1.4, CAP], segs: [{ k: 'L', to: [0, BASE] }] },
+        ],
+    },
+    {
+        ch: 'Y',
+        advance: 1.4,
+        strokes: [
+            { start: [0, CAP], segs: [{ k: 'L', to: [0.7, -1] }] },
+            // 右斜进到交点后直下,一笔
+            { start: [1.4, CAP], segs: [{ k: 'L', to: [0.7, -1] }, { k: 'L', to: [0.7, BASE] }] },
+        ],
+    },
+    {
+        ch: 'Z',
+        advance: 1.4,
+        strokes: [
+            { start: [0, CAP], segs: [
+                    { k: 'L', to: [1.4, CAP] },
+                    { k: 'L', to: [0, BASE] },
+                    { k: 'L', to: [1.4, BASE] },
+                ] },
+        ],
+    },
+];
+/** A–Z → 字形 */
+export const UPPERCASE = new Map(CAPITALS.map((g) => [g.ch, g]));

package/dist/chalk/glyphs/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * chalk/glyphs —— 拉丁字母的笔顺资源包(a–z 与 A–Z)。
+ *
+ * 给的是"这个字母怎么一笔一笔写出来":52 个字形的归一化笔顺数据,
+ * 加一个把它铺成 freedraw skeleton 的笔。孩子端的单词卡、英文听写的格子用它,
+ * 于是"演示写字"和"讲解动画"是同一条渲染链、同一种逐笔动画。
+ *
+ * 坐标与四线三格对齐(x 高 = 1、基线 = 0、升部 -2、降部 +1),
+ * 因此既能画,也能拿 LOWERCASE 的归一化数据去跟孩子的手写笔迹比对。
+ *
+ * 本包只收拉丁字母:数字与符号各有各的笔顺流派与消费方,不在此处硬凑。
+ */
+export type { Glyph, GlyphStroke, Seg, SegLine, SegArc, SegCubic } from './types.ts';
+export { LOWERCASE } from './letters.ts';
+export { UPPERCASE } from './capitals.ts';
+export { GLYPHS } from './registry.ts';
+export { GUIDES, ASC, CAP, XT, BASE, DESC } from './metrics.ts';
+export { sampleStroke, strokeLength, glyphBBox, SAMPLE_STEP } from './sample.ts';
+export type { Pt } from './sample.ts';
+export { glyphSkeletons, wordSkeletons, wordAdvance, UnknownGlyphError, SPACE_ADVANCE } from './skeleton.ts';
+export type { GlyphPenOptions } from './skeleton.ts';

package/dist/chalk/glyphs/index.js

@@ -0,0 +1,18 @@
+/**
+ * chalk/glyphs —— 拉丁字母的笔顺资源包(a–z 与 A–Z)。
+ *
+ * 给的是"这个字母怎么一笔一笔写出来":52 个字形的归一化笔顺数据,
+ * 加一个把它铺成 freedraw skeleton 的笔。孩子端的单词卡、英文听写的格子用它,
+ * 于是"演示写字"和"讲解动画"是同一条渲染链、同一种逐笔动画。
+ *
+ * 坐标与四线三格对齐(x 高 = 1、基线 = 0、升部 -2、降部 +1),
+ * 因此既能画,也能拿 LOWERCASE 的归一化数据去跟孩子的手写笔迹比对。
+ *
+ * 本包只收拉丁字母:数字与符号各有各的笔顺流派与消费方,不在此处硬凑。
+ */
+export { LOWERCASE } from "./letters.js";
+export { UPPERCASE } from "./capitals.js";
+export { GLYPHS } from "./registry.js";
+export { GUIDES, ASC, CAP, XT, BASE, DESC } from "./metrics.js";
+export { sampleStroke, strokeLength, glyphBBox, SAMPLE_STEP } from "./sample.js";
+export { glyphSkeletons, wordSkeletons, wordAdvance, UnknownGlyphError, SPACE_ADVANCE } from "./skeleton.js";

package/dist/chalk/glyphs/letters.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 26 个小写拉丁字母的笔顺(print 分写体,英美小学通行写法)。大写在 capitals.ts。
+ *
+ * 一个字形一条记录,strokes 顺序 = 教学笔顺;圈类字母(a c d e g o q)逆时针,
+ * 拱类(h m n r)先竖后拱,点(i j)最后落。选型口径见 docs/glyphs.md。
+ *
+ * 坐标是归一化的四线三格(metrics.ts):x 高 = 1,基线 = 0,升部 -2,降部 +1。
+ * 数值经 snap 逐字调过;改动请重跑 `node --experimental-strip-types tests/letters.test.ts`
+ * 与字母表 snap,几何断言(升降部到位、笔画连续、墨迹不越界)会挡住手滑。
+ */
+import type { Glyph } from './types.ts';
+/** a–z → 字形;查不到的字符由调用方决定怎么办(本包不猜) */
+export declare const LOWERCASE: ReadonlyMap<string, Glyph>;