@xiaobuyu/nodesign 0.0.7 → 0.0.8

package/server/lib/sketch-stencils.js

@@ -0,0 +1,170 @@
+/**
+ * server/lib/sketch-stencils.js —— 图形词汇表（2026-08-30 画图能力线刀①）
+ *
+ * 参数化简笔画：agent 说「这里一座房子、两格宽」，机器展开成手工调好的 path。
+ * 跟落位那条线同一个哲学 —— **语义归 agent，几何外包**：画什么、放哪、多大
+ * 它定，一笔一画的坐标不用它算。
+ *
+ * ## 词表纪律
+ *
+ * 词表就是 agent 的词汇量（风格命名那条经验）：几十个精选 > 无限自由。入选判据
+ * 是「侦探板 / 跑团 / 示意图里真会反复用到」。每个 stencil 是 0..100 规范框里的
+ * 一组笔画（多条 d），使用时缩放到目标尺寸、逐笔过手绘抖动 —— 跟整个画图族
+ * 同一支笔。新增一个词 = 加一条数据，代码零改动。
+ *
+ * ⚠️ 笔画坐标手工调过、**逐个看过渲染**（scripts 探针）。改的时候别信脑内想象，
+ * 渲染出来看 —— 画错的 path 比没有更坏。
+ */
+
+/** 每个词：strokes = 0..100 框内的笔画（大写绝对 M/L/Q/C/Z）；aspect = 高/宽 */
+export const STENCILS = {
+  person: {
+    aspect: 1.6,
+    strokes: [
+      'M50,4 C60,4 66,11 66,20 C66,29 60,36 50,36 C40,36 34,29 34,20 C34,11 40,4 50,4 Z',
+      'M50,36 L50,64',
+      'M22,52 L50,42 L78,52',
+      'M50,64 L32,98',
+      'M50,64 L68,98',
+    ],
+  },
+  house: {
+    aspect: 1,
+    strokes: [
+      'M14,48 L50,14 L86,48',
+      'M22,48 L22,92 L78,92 L78,48',
+      'M44,92 L44,66 L58,66 L58,92',
+    ],
+  },
+  tree: {
+    aspect: 1.3,
+    strokes: [
+      'M50,96 L50,58',
+      'M50,58 C28,62 16,46 28,34 C26,16 52,8 60,22 C78,20 84,42 68,48 C66,58 56,62 50,58 Z',
+    ],
+  },
+  pine: {
+    aspect: 1.5,
+    strokes: [
+      'M50,4 L30,36 L42,36 L24,64 L38,64 L18,92 L82,92 L62,64 L76,64 L58,36 L70,36 Z',
+      'M50,92 L50,100',
+    ],
+  },
+  mountain: {
+    aspect: 0.6,
+    strokes: [
+      'M2,96 L34,28 L50,58 L66,10 L98,96',
+      'M58,34 L66,22 L74,36',
+    ],
+  },
+  boat: {
+    aspect: 0.9,
+    strokes: [
+      'M18,74 L82,74 L70,92 L30,92 Z',
+      'M52,74 L52,12',
+      'M52,16 L84,68 L52,68 Z',
+      'M48,24 L24,68 L48,68 Z',
+    ],
+  },
+  flag: {
+    aspect: 1.4,
+    strokes: [
+      'M32,4 L32,98',
+      'M32,8 Q54,16 74,10 L74,34 Q54,40 32,32 Z',
+    ],
+  },
+  star: {
+    aspect: 1,
+    strokes: [
+      'M50,6 L60,36 L92,37 L66,56 L76,88 L50,69 L24,88 L34,56 L8,37 L40,36 Z',
+    ],
+  },
+  moon: {
+    aspect: 1.2,
+    strokes: [
+      'M62,6 C36,14 24,42 34,66 C41,83 55,93 70,92 C50,84 40,62 46,42 C50,28 55,14 62,6 Z',
+    ],
+  },
+  sun: {
+    aspect: 1,
+    strokes: [
+      'M50,28 C63,28 72,37 72,50 C72,63 63,72 50,72 C37,72 28,63 28,50 C28,37 37,28 50,28 Z',
+      'M50,2 L50,16 M50,84 L50,98 M2,50 L16,50 M84,50 L98,50',
+      'M17,17 L27,27 M73,73 L83,83 M83,17 L73,27 M27,73 L17,83',
+    ],
+  },
+  cloud: {
+    aspect: 0.55,
+    strokes: [
+      'M24,78 C6,78 6,54 24,54 C24,32 52,26 60,42 C70,26 94,36 90,54 C104,58 100,78 84,78 Z',
+    ],
+  },
+  scroll: {
+    aspect: 1.2,
+    strokes: [
+      'M18,18 C18,10 82,10 82,18 C82,26 18,26 18,18 Z',
+      'M24,26 L24,80 M76,26 L76,80',
+      'M18,86 C18,78 82,78 82,86 C82,94 18,94 18,86 Z',
+      'M36,42 L64,42',
+      'M36,54 L64,54',
+      'M36,66 L58,66',
+    ],
+  },
+  sword: {
+    aspect: 1.6,
+    strokes: [
+      'M50,2 L43,60 L50,70 L57,60 Z',
+      'M34,62 L66,62',
+      'M50,70 L50,92',
+      'M44,95 L56,95',
+    ],
+  },
+  dice: {
+    aspect: 1,
+    strokes: [
+      'M20,20 L80,20 L80,80 L20,80 Z',
+      'M35,33 C38,33 38,37 35,37 C32,37 32,33 35,33 Z',
+      'M50,48 C53,48 53,52 50,52 C47,52 47,48 50,48 Z',
+      'M65,63 C68,63 68,67 65,67 C62,67 62,63 65,63 Z',
+    ],
+  },
+  heart: {
+    aspect: 0.95,
+    strokes: [
+      'M50,88 C16,58 22,20 50,36 C78,20 84,58 50,88 Z',
+    ],
+  },
+  door: {
+    aspect: 1.6,
+    strokes: [
+      'M26,96 L26,26 C26,10 74,10 74,26 L74,96',
+      'M26,96 L74,96',
+      'M62,56 C65,56 65,60 62,60 C59,60 59,56 62,56 Z',
+    ],
+  },
+};
+
+export const STENCIL_NAMES = Object.keys(STENCILS);
+
+/**
+ * 展开一个词：缩放到 w×h（像素），返回未抖动的笔画（抖动由调用方按 seed 加 ——
+ * 阵列的每份要各自的抖）。
+ * @returns {{ strokes: string[], w:number, h:number }}
+ */
+export function stencilStrokes(name, wPx, hPx = null) {
+  const st = STENCILS[name];
+  if (!st) return null;
+  const w = Math.max(8, wPx);
+  const h = Math.max(8, hPx || w * st.aspect);
+  // ⚠️ 奇偶计数器**每条笔画各自数**：跨笔画累计的话，一条 d 的数字个数为奇数
+  // 就把后面所有笔画的 x/y 错位成 y/x
+  return { strokes: st.strokes.map((d) => scaleD(d, w / 100, h / 100)), w, h };
+}
+
+function scaleD(d, sx, sy) {
+  let k = 0;
+  return d.replace(/-?\d*\.?\d+/g, (n) => {
+    const v = Number(n) * ((k++ % 2 === 0) ? sx : sy);
+    return String(Math.round(v * 10) / 10);
+  }).replace(/,/g, ' ');
+}

package/server/lib/state-table.js

@@ -0,0 +1,237 @@
+/**
+ * server/lib/state-table.js —— 状态表：板上那张 `| 键 | 值 |` 的解析与改写
+ * （2026-08-30）
+ *
+ * ## 为什么真相是一张 markdown 表，不是一份 JSON
+ *
+ * 演出里"会变、要记得"的东西（好感度 / 时间 / 线索 / 体力）此前住在状态板的正文里，
+ * 是一段自由文本，每拍靠 agent 整卡重写。想让程序参与（下一轮提醒它、将来按条件
+ * 触发）就得有结构。
+ *
+ * 结构可以另起一份存储（`.nd/vars.json` 之类），但那条路被两件事否掉：
+ *   - `.nd/` 在 gitignore 里（workspace-templates.js）。存那儿 = 用户在画布上看不见、
+ *     git 里没历史、`revertWorkspace` 回滚正文却不回滚它 →「旧故事配新数值」，
+ *     而且没有任何东西会报这个错。
+ *   - 另起一份 = 同一件事两份真相。状态板的字**已经**在 `notes/板书/` 里、已经进 git、
+ *     已经每轮 commit。再存一份就是这条线上翻过最多次车的那种账。
+ *
+ * 所以：**真相仍是那条板书文件，只是约定它正文里有一张固定格式的表。**
+ * 服务端只读解析出派生值喂每轮状态块；`set_vars` 做的是"精确改表里那一格"，
+ * 不是重写整张卡。文件内容 = 显示内容 = agent Read 到的内容，三者逐字相同。
+ *
+ * ## 定位判据：tag，不是文件名、不是隐形标记
+ *
+ * ⛔ **不能用藏在 frontmatter 里的自造键**：`renderChalk` 只回写白名单键，
+ *    一次 `edit_board set_text` 就把它整行丢掉，而且不报错。
+ * ⛔ **不能用固定文件名**（`状态表.md` 那种）：chalk 目录的文件名是时间戳，
+ *    `recentChalk` 和首页摘句都拿"文件名倒序"当"最近"判据 —— 一个 CJK 开头的
+ *    固定名在字典序里排在所有数字时间戳之后，倒序后永远第一，
+ *    结果是**首页每个演出项目的卡常年显示「| 键 | 值 |」**。
+ * ✅ 用 `tag: 状态表`（专用 tag，跟状态板那个**组** tag 分开）。tag 是少数能双向
+ *    往返的字段（parseChalk 读、renderChalk 写、set_text 保留），改名搬位都不影响。
+ */
+
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { CHALK_DIR, parseChalk } from './chalk.js';
+
+/** 状态表专用 tag。⚠️ 跟 blackboard-rp 的「状态板」组 tag 是两个东西：
+ *  那个是一**组**卡（PC卡/场景/明骰表）的组名，这个专指承载键值表的那一条。 */
+export const STATE_TABLE_TAG = '状态表';
+
+/** 值的上限：一格里塞长文是把表当笔记本用，那是板书正文的活 */
+export const VALUE_MAX = 120;
+/** 键的上限与字符集：键要能当标识符用（将来触发器按它寻址），别收任意文本 */
+export const KEY_MAX = 40;
+const KEY_RE = /^[\p{L}\p{N}_][\p{L}\p{N}_·-]{0,39}$/u;
+
+/**
+ * 剥掉围栏块再找表。
+ * 板书里最常见的围栏是 ```nd:controls（控件声明），里面完全可能出现竖线。
+ * 判据抄 board-excerpt.js 的 excerptOf —— 那儿已经为同一个理由剥过一次。
+ */
+export function stripFences(body) {
+  return String(body || '')
+    .replace(/^[ \t]*```[\s\S]*?^[ \t]*```[ \t]*$|^[ \t]*```[\s\S]*$/gm, '');
+}
+
+const SEP_RE = /^\s*\|?[\s:-]*-[-\s:|]*\|?\s*$/;      // | --- | --- |
+const HEAD_RE = /^\s*\|\s*键\s*\|\s*值\s*\|\s*$/;
+const FENCE_RE = /^[ \t]*```/;
+
+/**
+ * 逐行标出「这一行在围栏里吗」。
+ *
+ * ⚠️ 不能用 stripFences 之后的**文本**去比对（第一版就是这么写的，当场翻车）：
+ * 围栏里那行 `| 键 | 值 |` 和真表头**逐字相同**，按内容判membership 两行都算"活着"，
+ * 于是一张表被数成两张。判据必须落在**行号**上，不是行的内容。
+ * 未闭合的围栏一路吃到末尾（跟 board-excerpt 的取舍一致：宁可少认，不能把源码当数据）。
+ */
+function fenceMask(lines) {
+  const mask = new Array(lines.length).fill(false);
+  let open = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    if (FENCE_RE.test(lines[i])) { mask[i] = true; open = !open; continue; }
+    mask[i] = open;
+  }
+  return mask;
+}
+
+function cells(line) {
+  return line.replace(/^\s*\|/, '').replace(/\|\s*$/, '').split('|').map((c) => c.trim());
+}
+
+/**
+ * 从正文里解析状态表。
+ *
+ * @returns {{ ok:true, start:number, end:number, rows:Array<{key,value}> }
+ *         | { ok:false, error:string }}
+ *   start/end 是表在**原始行数组**里的下标区间（含表头与分隔行），改写时按它回填。
+ *   ok:false 的两种：没有表、或者有歧义（多张表 / 重复键）—— 一律**大声**，
+ *   不 fail-soft 成空表。空表和"读不懂"是两件事，混在一起就是那条最贵的教训。
+ */
+export function parseStateTable(body) {
+  const raw = String(body || '').split(/\r?\n/);
+  const inFence = fenceMask(raw);
+  const heads = [];
+  for (let i = 0; i < raw.length; i += 1) {
+    if (!HEAD_RE.test(raw[i])) continue;
+    if (inFence[i]) continue;                     // 表头在围栏里 → 不算表
+    heads.push(i);
+  }
+  if (!heads.length) return { ok: false, error: 'no-table' };
+  if (heads.length > 1) {
+    return { ok: false, error: `这条板书里有 ${heads.length} 张「| 键 | 值 |」表 —— 状态表只能有一张，另一张挪到别的板书上去（明骰表用别的表头）。` };
+  }
+  const start = heads[0];
+  if (!SEP_RE.test(raw[start + 1] || '')) {
+    return { ok: false, error: '「| 键 | 值 |」下面缺分隔行（`|---|---|`），这不是一张合法的 markdown 表。' };
+  }
+  const rows = []; const seen = new Map();
+  let end = start + 1;
+  for (let i = start + 2; i < raw.length; i += 1) {
+    const line = raw[i];
+    if (!/^\s*\|/.test(line)) break;              // 表到此为止
+    const c = cells(line);
+    if (c.length < 2) break;
+    const key = c[0]; const value = c[1];
+    if (!key) { end = i; continue; }               // 空键行：留着但不算数据
+    if (seen.has(key)) {
+      return { ok: false, error: `表里「${key}」出现了两次（第 ${seen.get(key) + 1} 行和第 ${i + 1} 行）—— 键必须唯一，先把重复的那行删掉。` };
+    }
+    seen.set(key, i);
+    rows.push({ key, value });
+    end = i;
+  }
+  return { ok: true, start, end, rows };
+}
+
+/** 值清洗：压一行、去掉会把表撑破的字符。钳了要说（返回 clamped 让调用方如实报） */
+export function sanitizeValue(v) {
+  const src = String(v ?? '');
+  const s = src
+    // 控制字符（含换行、制表、行分隔符）先抹平：一格里塞多行会把表拆散，
+    // 而且拆散之后解析器只会少读几行，不会报错 —— 这类静默降级要堵在写口。
+    .replace(/[\u0000-\u001f\u007f\u2028\u2029]/g, ' ')
+    .replace(/\|/g, '/')                       // 竖线会当场炸表
+    .replace(/\s+/g, ' ')
+    .trim();
+  return { value: s.slice(0, VALUE_MAX), clamped: s.length > VALUE_MAX || src.includes('|') };
+}
+
+export function validateKey(k) {
+  const s = String(k ?? '').trim();
+  if (!s) return '键是空的';
+  if (s.length > KEY_MAX) return `键「${s.slice(0, 12)}…」超过 ${KEY_MAX} 字`;
+  if (!KEY_RE.test(s)) return `键「${s}」含不能用的字符（只收字母数字、中文、下划线、连字符、间隔号，且不能以连字符开头）`;
+  return null;
+}
+
+/** 把一张表渲染回 markdown 行（列宽不对齐 —— 对齐了 diff 会整片变） */
+export function renderRows(rows) {
+  return ['| 键 | 值 |', '| --- | --- |', ...rows.map((r) => `| ${r.key} | ${r.value} |`)];
+}
+
+/**
+ * 在正文里改/加若干个键，返回新正文与实际发生的变化。
+ * 表不存在或看不懂时**抛** —— 调用方负责把话说清楚。
+ */
+export function applyVars(body, vars) {
+  const parsed = parseStateTable(body);
+  if (!parsed.ok) {
+    const err = new Error(parsed.error === 'no-table'
+      ? '这条板书里没有「| 键 | 值 |」表。'
+      : parsed.error);
+    err.code = parsed.error === 'no-table' ? 'NO_TABLE' : 'BAD_TABLE';
+    throw err;
+  }
+  const rows = parsed.rows.map((r) => ({ ...r }));
+  const changed = []; const added = []; const clamped = [];
+  for (const [rawKey, rawVal] of Object.entries(vars)) {
+    const key = String(rawKey).trim();
+    const bad = validateKey(key);
+    if (bad) { const e = new Error(bad); e.code = 'BAD_KEY'; throw e; }
+    const { value, clamped: cl } = sanitizeValue(rawVal);
+    if (cl) clamped.push(key);
+    const hit = rows.find((r) => r.key === key);
+    if (hit) { if (hit.value !== value) changed.push({ key, from: hit.value, to: value }); hit.value = value; }
+    else { rows.push({ key, value }); added.push({ key, value }); }
+  }
+  const lines = String(body).split(/\r?\n/);
+  const next = [...lines.slice(0, parsed.start), ...renderRows(rows), ...lines.slice(parsed.end + 1)];
+  return { body: next.join('\n'), rows, changed, added, clamped };
+}
+
+/**
+ * 在工作区里找那条状态表板书。
+ * @returns {{ found:true, rel, abs, raw, body, chalk }
+ *         | { found:false, reason:'none' }
+ *         | { found:false, reason:'multiple', rels:string[] }}
+ */
+export async function findStateTable(sharedRoot) {
+  const dir = path.join(sharedRoot, CHALK_DIR);
+  let names;
+  try {
+    names = (await fs.readdir(dir)).filter((n) => n.endsWith('.md') && !n.startsWith('.'));
+  } catch { return { found: false, reason: 'none' }; }
+  const hits = [];
+  for (const n of names) {
+    let raw;
+    try { raw = await fs.readFile(path.join(dir, n), 'utf8'); } catch { continue; }
+    const { body, chalk } = parseChalk(raw);
+    if (chalk?.tag === STATE_TABLE_TAG) {
+      hits.push({ rel: `${CHALK_DIR}/${n}`, abs: path.join(dir, n), raw, body, chalk });
+    }
+  }
+  if (!hits.length) return { found: false, reason: 'none' };
+  if (hits.length > 1) return { found: false, reason: 'multiple', rels: hits.map((h) => h.rel) };
+  return { found: true, ...hits[0] };
+}
+
+/**
+ * 给每轮状态块用的读侧。**永远返回一个可渲染的结果**，但「读不懂」和「没有」
+ * 是两种不同的返回 —— 上一轮还解析得出、这一轮解析不出，调用方要能报警。
+ * @returns {{ state:'none' } | { state:'ok', rel, rows, body } | { state:'broken', rel?, why }}
+ */
+export async function readStateVars(sharedRoot) {
+  const f = await findStateTable(sharedRoot);
+  if (!f.found) {
+    if (f.reason === 'multiple') {
+      return { state: 'broken', why: `板上有 ${f.rels.length} 条 tag 是「${STATE_TABLE_TAG}」的板书（${f.rels.join('、')}）—— 只能有一条。` };
+    }
+    return { state: 'none' };
+  }
+  const parsed = parseStateTable(f.body);
+  if (!parsed.ok) {
+    return {
+      state: 'broken',
+      rel: f.rel,
+      why: parsed.error === 'no-table'
+        ? `${f.rel} 挂着「${STATE_TABLE_TAG}」的 tag，但正文里找不到「| 键 | 值 |」表。`
+        : parsed.error,
+    };
+  }
+  // body 一起带回：触发器的声明（```nd:triggers 围栏）就住在这条板书的正文里，
+  // 调用方拿它去解析，省一次读盘也省一次"两边读的是不是同一份"的疑虑。
+  return { state: 'ok', rel: f.rel, rows: parsed.rows, body: f.body };
+}

package/server/lib/state-trend.js

@@ -0,0 +1,94 @@
+/**
+ * server/lib/state-trend.js —— 状态表的历史序列（2026-08-30 画图能力线·活图第一块）
+ *
+ * 状态表住在一条板书文件里、板书文件进 git、工作区**每回合落一个 commit**
+ * （session-loop turn commit）—— 所以「好感度随拍数怎么走」的序列是**现成的**，
+ * 不用第二份存储不用记账，git 就是时间轴。这是别家没有的弹药。
+ *
+ * 读侧纪律与状态表同款：拿不到就大声说拿不到（没有表 / 历史不足 / 值不是数字），
+ * 不画一根瞎编的线。git 操作全只读（log/show），不进写 mutex。
+ */
+
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { findStateTable, parseStateTable } from './state-table.js';
+import { parseChalk } from './chalk.js';
+
+const run = promisify(execFile);
+const MAX_POINTS = 80;
+
+/** 值里抠数字：`5`→5、`8/10`→8、`≈3.5`→3.5；抠不出返回 null */
+export function numOf(value) {
+  const m = /-?\d+(?:\.\d+)?/.exec(String(value ?? ''));
+  return m ? Number(m[0]) : null;
+}
+
+/**
+ * 某个键的历史序列（旧→新，末尾是**盘上现值**——本回合改了还没 commit 的也算数）。
+ * @returns {{ ok:true, points:number[], rel:string } |
+ *           { ok:false, why:string, rel?:string, points?:number[] }}
+ */
+export async function trendSeries(sharedRoot, key) {
+  const f = await findStateTable(sharedRoot);
+  if (!f.found) return { ok: false, why: f.reason === 'multiple' ? '有两条挂着状态表 tag 的板书，先合成一条' : '板上还没有状态表（tag: 状态表 的那条板书）' };
+  const rel = f.rel;
+
+  let hashes = [];
+  try {
+    const { stdout } = await run('git', ['log', '--format=%H', '--reverse', '--follow', '--', rel], { cwd: sharedRoot });
+    hashes = stdout.trim().split('\n').filter(Boolean);
+  } catch { /* 没有 git 历史就只有现值 */ }
+  if (hashes.length > MAX_POINTS) hashes = hashes.slice(hashes.length - MAX_POINTS);
+
+  const points = [];
+  for (const h of hashes) {
+    try {
+      const { stdout } = await run('git', ['show', `${h}:${rel}`], { cwd: sharedRoot });
+      const rows = parseStateTable(parseChalk(stdout).body || '');
+      if (!rows.ok) continue;
+      const row = rows.rows.find((r) => r.key === key);
+      if (!row) continue;
+      const v = numOf(row.value);
+      if (v === null) continue;
+      // 同值连点不压缩：横盘也是信息（十拍没动 = 一条平线）
+      points.push(v);
+    } catch { /* 某个版本读不出就跳过 */ }
+  }
+
+  // 盘上现值收尾（本回合 set_vars 改过、还没 commit）
+  const { readStateVars } = await import('./state-table.js');
+  const live = await readStateVars(sharedRoot);
+  if (live.state === 'ok') {
+    const row = live.rows.find((r) => r.key === key);
+    const v = row ? numOf(row.value) : null;
+    if (v !== null && (points.length === 0 || v !== points[points.length - 1])) points.push(v);
+    if (row && v === null) return { ok: false, rel, why: `「${key}」的现值是「${row.value}」，抠不出数字 —— 趋势线只画得了数` };
+    if (!row) return { ok: false, rel, why: `状态表里没有「${key}」这个键` };
+  }
+  if (points.length < 2) {
+    return { ok: false, rel, points, why: `「${key}」目前只有 ${points.length} 个数据点（历史随每回合的 git commit 长出来）—— 至少两点才有线，过几拍再画` };
+  }
+  return { ok: true, points, rel };
+}
+
+/**
+ * 序列 → 手绘折线的**几何**（局部像素；抖动由调用方加，跟全族同一支笔）。
+ * @returns {{ w,h, lineD:string, baselineD:string, dotD:string, min:number, max:number }}
+ */
+export function trendGeometry(points, { w = 336, h = 120 } = {}) {
+  const P = 8;
+  const min = Math.min(...points); const max = Math.max(...points);
+  const span = (max - min) || 1;
+  const iw = w - P * 2; const ih = h - P * 2;
+  const xy = points.map((v, i) => ({
+    x: P + (points.length === 1 ? iw / 2 : (i / (points.length - 1)) * iw),
+    y: P + ih - ((v - min) / span) * ih,
+  }));
+  const f = (n) => Math.round(n * 10) / 10;
+  const lineD = xy.map((p, i) => `${i ? 'L' : 'M'} ${f(p.x)} ${f(p.y)}`).join(' ');
+  const last = xy[xy.length - 1];
+  // 端点小圈（现值在哪）
+  const r = 3;
+  const dotD = `M ${f(last.x - r)} ${f(last.y)} C ${f(last.x - r)} ${f(last.y - r * 1.4)} ${f(last.x + r)} ${f(last.y - r * 1.4)} ${f(last.x + r)} ${f(last.y)} C ${f(last.x + r)} ${f(last.y + r * 1.4)} ${f(last.x - r)} ${f(last.y + r * 1.4)} ${f(last.x - r)} ${f(last.y)}`;
+  return { w, h, lineD, baselineD: `M ${P} ${h - P} L ${w - P} ${h - P}`, dotD, min, max };
+}