@cardenelabs/dragon 0.7.0

package/src/notation-lint.ts

@@ -0,0 +1,304 @@
+/**
+ * Notation lint (author 向け修正システム)。
+ *
+ * cdl / dragon 記法で書かれた CdlDiagram を rule-based に検査し、
+ * 「もっと良い書き方」 を suggestion として返す純粋関数。 LLM 不要、 rule のみ。
+ *
+ * 検知システム (`check:cdl` / `check:dragon` / `check:kind`) は開発陣向けで
+ * 「実装バグ」 を検出するが、 本 notation-lint は **author 向け** で
+ * 「書き方の癖 / 冗長表現 / 未定義参照 / 空 payload」 等を検出する。
+ *
+ * 使い方:
+ *   import { lintDiagram } from "@cardenelabs/dragon";
+ *   const report = lintDiagram(diagram);
+ *   // report.issues[] = LintIssue[]
+ *   // report.fixed = LintIssue[] のうち自動修正で解消される件
+ *   // report.autoFix(diagram) = 修正済 CdlDiagram
+ *
+ * CLI:
+ *   pnpm dragon-lint apps/playground-spa/src/topics/catalog/presets.cdl.ts
+ */
+import type { CdlDiagram, CdlNode } from "@cardenelabs/cdl";
+
+export type LintSeverity = "warn" | "info";
+
+export type LintIssue = {
+  /** rule 識別子 */
+  rule: string;
+  severity: LintSeverity;
+  /** 該当対象 (node id / edge id / diagram id) */
+  target: string;
+  /** 人間向けメッセージ */
+  message: string;
+  /** 修正案 (自動修正可能なら適用後の値、 手動修正必要なら null) */
+  suggestion?: string;
+  /** autoFix() が本 issue を自動解消できるか */
+  autoFixable: boolean;
+};
+
+export type LintReport = {
+  diagramId: string;
+  issues: LintIssue[];
+  /** autoFix() が実際に解消できる issue の数 */
+  autoFixableCount: number;
+};
+
+const REDUNDANT_TOPIC_PATTERNS: Array<{ pattern: RegExp; hint: string }> = [
+  { pattern: /\bpreset\s*\(/i, hint: "「〜 preset (詳細)」 は実装表現、 「〜 を示す図」 のように読者向け説明に" },
+  { pattern: /render\s*未実装/, hint: "「render 未実装」 は開発者向け内部メモ、 catalog 表示では省く" },
+  { pattern: /SVG\s+(polyline|arc|rect|path)/i, hint: "「SVG polyline / arc / rect / path」 は実装詳細、 「〜 を示す図」 に置換" },
+  { pattern: /\bpolygon\b/i, hint: "「polygon」 は実装用語、 図の意味を説明する自然文に置換" },
+];
+
+/**
+ * 検査対象 diagram の全 rule を実行し LintReport を返す。
+ * 全 rule は純粋 (副作用なし / LLM 呼び出しなし)。
+ */
+export function lintDiagram(d: CdlDiagram): LintReport {
+  const issues: LintIssue[] = [];
+
+  issues.push(...ruleTopicRedundancy(d));
+  issues.push(...ruleEmptyChartData(d));
+  issues.push(...ruleGanttUnknownDependsOn(d));
+  issues.push(...ruleMindMapParentReference(d));
+  issues.push(...ruleTreeParentReference(d));
+  issues.push(...ruleQuadrantMissingItems(d));
+  issues.push(...ruleFunnelMonotonicCount(d));
+
+  return {
+    diagramId: d.id,
+    issues,
+    autoFixableCount: issues.filter((i) => i.autoFixable).length,
+  };
+}
+
+/**
+ * lintDiagram で detected な issue のうち autoFixable=true のものを機械的に適用して
+ * 修正済 CdlDiagram を返す。 手動修正必要な issue は残る (次回 lint 時に再検出)。
+ */
+export function autoFix(d: CdlDiagram): CdlDiagram {
+  const patched: CdlDiagram = {
+    ...d,
+    topic: applyTopicAutoFix(d.topic),
+    nodes: d.nodes.map((n) => ({ ...n })),
+  };
+  return patched;
+}
+
+const KIND_TO_JA: Record<string, string> = {
+  chart: "統計チャート",
+  "line chart": "折れ線グラフ",
+  "pie chart": "円グラフ",
+  "bar chart": "棒グラフ",
+  flow: "処理の流れ",
+  swimlane: "スイムレーン (役割別レーン)",
+  sequence: "時系列のやり取り",
+  topology: "システム構成",
+  er: "テーブル関係 (ER 図)",
+  stateMachine: "状態遷移 (ステート図)",
+  stateMachine2: "拡張ステート図 (階層状態)",
+  infrastructure: "クラウド構成",
+  classDiagram: "UML クラス図",
+  tree: "階層ツリー",
+  userJourney: "ユーザージャーニー",
+  mindMap: "マインドマップ",
+  mindMapRadial: "放射状マインドマップ",
+  funnel: "ファネル (段階別離脱)",
+  quadrant: "四象限マトリクス",
+  gantt: "ガントチャート",
+  flowchart: "分岐フローチャート",
+  network: "ネットワーク構成",
+};
+
+function applyTopicAutoFix(topic: string): string {
+  // 1. 先頭の kind name を検出、 マッチしたら JA description に置換
+  const kindMatch = topic.match(
+    /^\s*(chart|flow|swimlane|sequence|topology|er|stateMachine2?|infrastructure|classDiagram|tree|userJourney|mindMap(?:Radial)?|funnel|quadrant|gantt|flowchart|network|line chart|pie chart|bar chart)\b/i,
+  );
+  if (kindMatch) {
+    const kind = kindMatch[1]!.toLowerCase();
+    const canonical = Object.keys(KIND_TO_JA).find((k) => k.toLowerCase() === kind);
+    if (canonical) {
+      return `${KIND_TO_JA[canonical]} を示す図`;
+    }
+  }
+
+  // 2. kind 名で始まらない場合は括弧内実装詳細のみ除去
+  let out = topic;
+  out = out.replace(/\s*\([^)]*(preset|render|SVG|polygon|polyline|arc|rect|path)[^)]*\)/gi, "");
+  out = out.replace(/\b(preset|render)\b/gi, "");
+  out = out.replace(/\s+/g, " ").trim();
+  if (out.length < 3) return "図の説明";
+  return out;
+}
+
+function ruleTopicRedundancy(d: CdlDiagram): LintIssue[] {
+  const out: LintIssue[] = [];
+  for (const { pattern, hint } of REDUNDANT_TOPIC_PATTERNS) {
+    if (pattern.test(d.topic)) {
+      out.push({
+        rule: "topic-redundant-implementation-detail",
+        severity: "warn",
+        target: d.id,
+        message: `topic に実装詳細が含まれる: "${d.topic}"`,
+        suggestion: hint,
+        autoFixable: true,
+      });
+    }
+  }
+  return out;
+}
+
+function ruleEmptyChartData(d: CdlDiagram): LintIssue[] {
+  const out: LintIssue[] = [];
+  for (const n of d.nodes) {
+    if (n.kind === "chart-line" || n.kind === "chart-pie" || n.kind === "chart-bar") {
+      const data = n.chartData ?? [];
+      if (data.length === 0) {
+        out.push({
+          rule: "chart-empty-datum",
+          severity: "warn",
+          target: n.id,
+          message: `chart node "${n.id}" が datum 0 件、 chart は非表示になる`,
+          suggestion: `.datum({ id: ..., label: ..., value: ... }) を 1 件以上追加`,
+          autoFixable: false,
+        });
+      }
+      if (data.length === 1) {
+        out.push({
+          rule: "chart-single-datum",
+          severity: "info",
+          target: n.id,
+          message: `chart node "${n.id}" が datum 1 件、 比較 / 推移として意味が薄い`,
+          suggestion: `2 件以上の datum を推奨 (line 系は 3 件以上で trend が見える)`,
+          autoFixable: false,
+        });
+      }
+    }
+  }
+  return out;
+}
+
+function ruleGanttUnknownDependsOn(d: CdlDiagram): LintIssue[] {
+  const out: LintIssue[] = [];
+  for (const n of d.nodes) {
+    if (n.kind === "gantt-timeline") {
+      const tasks = n.ganttData ?? [];
+      const ids = new Set(tasks.map((t) => t.id));
+      for (const t of tasks) {
+        if (t.dependsOn && !ids.has(t.dependsOn)) {
+          out.push({
+            rule: "gantt-unknown-depends-on",
+            severity: "warn",
+            target: t.id,
+            message: `task "${t.id}" が未定義 task "${t.dependsOn}" に dependsOn 参照`,
+            suggestion: `参照先 id を修正 or dependsOn を除去`,
+            autoFixable: false,
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+
+function ruleMindMapParentReference(d: CdlDiagram): LintIssue[] {
+  const out: LintIssue[] = [];
+  for (const n of d.nodes) {
+    if ((n.kind === "mind-map" || n.kind === "mind-radial") && n.mindData) {
+      const known = new Set<string>([n.mindData.rootId]);
+      for (const b of n.mindData.branches) known.add(b.id);
+      for (const b of n.mindData.branches) {
+        if (!known.has(b.parent)) {
+          out.push({
+            rule: "mindmap-unknown-parent",
+            severity: "warn",
+            target: b.id,
+            message: `branch "${b.id}" が未定義 parent "${b.parent}" を参照`,
+            suggestion: `parent を rootId ("${n.mindData.rootId}") または既存 branch id に修正`,
+            autoFixable: false,
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+
+function ruleTreeParentReference(d: CdlDiagram): LintIssue[] {
+  const out: LintIssue[] = [];
+  for (const n of d.nodes) {
+    if (n.kind === "tree-hierarchy" && n.treeData) {
+      const ids = new Set(n.treeData.map((t) => t.id));
+      for (const t of n.treeData) {
+        if (t.parent && !ids.has(t.parent)) {
+          out.push({
+            rule: "tree-unknown-parent",
+            severity: "warn",
+            target: t.id,
+            message: `tree node "${t.id}" が未定義 parent "${t.parent}" を参照`,
+            suggestion: `parent id を既存 tree node に修正 or parent 除去 (root にする)`,
+            autoFixable: false,
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+
+function ruleQuadrantMissingItems(d: CdlDiagram): LintIssue[] {
+  const out: LintIssue[] = [];
+  for (const n of d.nodes) {
+    if (n.kind === "quadrant-matrix" && n.quadrantData) {
+      const items = n.quadrantData.items;
+      if (items.length === 0) {
+        out.push({
+          rule: "quadrant-empty",
+          severity: "warn",
+          target: n.id,
+          message: `quadrant "${n.id}" が item 0 件、 軸のみ表示される`,
+          suggestion: `.item({ id: ..., title: ..., quadrant: "topLeft" | ... }) を 1 件以上追加`,
+          autoFixable: false,
+        });
+      }
+      const bySlot = new Set(items.map((it) => it.quadrant));
+      if (items.length >= 4 && bySlot.size === 1) {
+        out.push({
+          rule: "quadrant-single-quadrant",
+          severity: "info",
+          target: n.id,
+          message: `quadrant "${n.id}" の item が 1 象限に集中、 マトリクスの意味が薄い`,
+          suggestion: `2 象限以上に item を分散 (SWOT / Priority matrix 等は 4 象限 balanced を推奨)`,
+          autoFixable: false,
+        });
+      }
+    }
+  }
+  return out;
+}
+
+function ruleFunnelMonotonicCount(d: CdlDiagram): LintIssue[] {
+  const out: LintIssue[] = [];
+  for (const n of d.nodes) {
+    if (n.kind === "funnel-stages" && n.funnelData) {
+      const stages = n.funnelData;
+      for (let i = 1; i < stages.length; i++) {
+        if (stages[i]!.count > stages[i - 1]!.count) {
+          out.push({
+            rule: "funnel-increasing-count",
+            severity: "warn",
+            target: stages[i]!.id,
+            message: `stage "${stages[i]!.id}" (${stages[i]!.count}) が前段 (${stages[i - 1]!.count}) より増加、 funnel は単調減少が期待される`,
+            suggestion: `stage 順を再確認、 増加 pattern なら別 preset (chart-line 等) を検討`,
+            autoFixable: false,
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+
+// dev-only import bridging (unused var lint prevention)
+export type { CdlDiagram, CdlNode };

package/src/parser.ts

@@ -0,0 +1,354 @@
+/**
+ * Text DSL parser
+ * 入力: docs/cdl/text-dsl-spec.md 準拠の箇条書きテキスト
+ * 出力: DslDocument AST or DslError[]
+ */
+
+import type {
+  DslDocument,
+  DslActor,
+  DslStep,
+  DslAnimate,
+  DslState,
+  DslPhase,
+  DslError,
+  PresetType,
+} from "./types";
+import type { NodeKind, Tone } from "@cardenelabs/cdl";
+import {
+  PRESET_NAMES,
+  NODE_KIND_ALIAS,
+  TONE_ALIAS,
+  normalizeArrow,
+  resolveHeader,
+  resolveAnimSubkey,
+  parseDuration,
+} from "./keywords";
+
+type Line = { raw: string; trimmed: string; indent: number; lineNo: number };
+
+function indentOf(s: string): number {
+  let n = 0;
+  for (const c of s) {
+    if (c === " ") n += 1;
+    else if (c === "\t") n += 2;
+    else break;
+  }
+  return n;
+}
+
+function splitLines(src: string): Line[] {
+  return src.split("\n").map((raw, i) => {
+    // # コメントを除去 (行末まで)
+    const noComment = raw.replace(/\s*#.*$/, "");
+    return {
+      raw,
+      trimmed: noComment.trim(),
+      indent: indentOf(noComment),
+      lineNo: i + 1,
+    };
+  });
+}
+
+function isBlank(l: Line): boolean {
+  return l.trimmed === "";
+}
+
+/** "key: value" を split */
+function splitKv(s: string): [string, string] | null {
+  const idx = s.indexOf(":");
+  if (idx < 0) return null;
+  return [s.slice(0, idx).trim(), s.slice(idx + 1).trim()];
+}
+
+/** 行の "- item (kind)" or "- item" を parse */
+function parseListItem(s: string): { name: string; paren?: string } | null {
+  const m = s.match(/^-\s*(.+?)(?:\s*\(\s*(.+?)\s*\))?\s*$/);
+  if (!m) return null;
+  return { name: m[1]!.trim(), paren: m[2]?.trim() };
+}
+
+/**
+ * Parser 本体
+ */
+export type ParseResult = { ok: true; doc: DslDocument } | { ok: false; errors: DslError[] };
+
+export function parseTextDsl(src: string): ParseResult {
+  const lines = splitLines(src);
+  const errors: DslError[] = [];
+
+  let title: string | undefined;
+  let type: PresetType | undefined;
+  const actors: DslActor[] = [];
+  const steps: DslStep[] = [];
+  let animate: DslAnimate | undefined;
+
+  let i = 0;
+  while (i < lines.length) {
+    const l = lines[i]!;
+    if (isBlank(l)) { i += 1; continue; }
+
+    // top-level header の検出 (`タイトル:` 等)
+    const kv = splitKv(l.trimmed);
+    if (kv && l.indent === 0) {
+      const header = resolveHeader(kv[0]);
+      if (header === "title") {
+        title = kv[1];
+        i += 1; continue;
+      }
+      if (header === "type") {
+        if (!(PRESET_NAMES as readonly string[]).includes(kv[1].toLowerCase())) {
+          errors.push({
+            line: l.lineNo,
+            message: `未知の種類 "${kv[1]}"`,
+            hint: `次から選んでください: ${PRESET_NAMES.join(" / ")}`,
+          });
+        }
+        type = kv[1].toLowerCase() as PresetType;
+        i += 1; continue;
+      }
+      if (header === "actors") {
+        // 次のブロック (indent > 0) を全部読む
+        i += 1;
+        while (i < lines.length && (lines[i]!.indent > 0 || isBlank(lines[i]!))) {
+          if (!isBlank(lines[i]!)) {
+            const a = parseActor(lines[i]!, errors);
+            if (a) actors.push(a);
+          }
+          i += 1;
+        }
+        continue;
+      }
+      if (header === "flow") {
+        i += 1;
+        while (i < lines.length && (lines[i]!.indent > 0 || isBlank(lines[i]!))) {
+          if (!isBlank(lines[i]!)) {
+            const s = parseStep(lines[i]!, errors, actors);
+            if (s) steps.push(s);
+          }
+          i += 1;
+        }
+        continue;
+      }
+      if (header === "animate") {
+        const r = parseAnimate(lines, i + 1, errors);
+        animate = r.anim;
+        i = r.nextIndex;
+        continue;
+      }
+    }
+
+    // 知らない top-level 行はスキップ (warning に降格、 ignore)
+    i += 1;
+  }
+
+  // 必須項目チェック
+  if (!title) errors.push({ line: 1, message: "タイトル: が見つかりません", hint: "ファイル先頭に `タイトル: <名前>` を追加" });
+  if (!type) errors.push({ line: 1, message: "種類: が見つかりません", hint: "ファイルに `種類: sequence` 等を追加" });
+  if (actors.length === 0) errors.push({ line: 1, message: "登場人物: ブロックが空または見つかりません", hint: "`登場人物:` の下に `- 名前 (種類)` を追加" });
+
+  if (errors.length > 0) return { ok: false, errors };
+
+  return {
+    ok: true,
+    doc: {
+      title: title!,
+      type: type!,
+      actors,
+      flow: steps,
+      animate,
+      pos: { line: 1 },
+    },
+  };
+}
+
+function parseActor(l: Line, errors: DslError[]): DslActor | null {
+  const item = parseListItem(l.trimmed);
+  if (!item) {
+    errors.push({ line: l.lineNo, message: `登場人物の書式エラー: "${l.trimmed}"`, hint: "`- 名前 (種類)` 形式で書いてください" });
+    return null;
+  }
+  let kind: NodeKind = "actor";
+  let kindWritten = false;
+  if (item.paren) {
+    const resolved = NODE_KIND_ALIAS[item.paren] ?? (item.paren as NodeKind);
+    kind = resolved;
+    kindWritten = true;
+  }
+  return { name: item.name, kind, kindWritten, pos: { line: l.lineNo } };
+}
+
+function parseStep(l: Line, errors: DslError[], actors: DslActor[]): DslStep | null {
+  // "1. ユーザー → API: ログイン情報 (成功)"
+  const m = l.trimmed.match(/^(\d+)\.\s*(.+)$/);
+  if (!m) {
+    errors.push({ line: l.lineNo, message: `流れの書式エラー: "${l.trimmed}"`, hint: "`番号. <from> → <to>: <ラベル>` 形式" });
+    return null;
+  }
+  const no = parseInt(m[1]!, 10);
+  const rest = normalizeArrow(m[2]!);
+  // "A → B: label (tone)"
+  const m2 = rest.match(/^(.+?)\s*→\s*(.+?)\s*:\s*(.+)$/);
+  if (!m2) {
+    errors.push({ line: l.lineNo, message: `矢印または ラベル なし: "${l.trimmed}"`, hint: "`<from> → <to>: <ラベル>` 形式" });
+    return null;
+  }
+  const from = m2[1]!.trim();
+  const to = m2[2]!.trim();
+  let labelPart = m2[3]!.trim();
+
+  // tone in () at end
+  let tone: Tone | undefined;
+  const toneMatch = labelPart.match(/^(.+?)\s*\(\s*(.+?)\s*\)\s*$/);
+  if (toneMatch) {
+    const resolved = TONE_ALIAS[toneMatch[2]!];
+    if (resolved) {
+      tone = resolved;
+      labelPart = toneMatch[1]!.trim();
+    }
+  }
+
+  // sub label syntax: "label (sub)" → label, sub の使い分けは tone と曖昧。
+  // 仕様 ... 末尾 (...) は tone を優先解釈、 tone エイリアスに一致しなければ sub。
+  let sub: string | undefined;
+  if (!tone && toneMatch) {
+    sub = toneMatch[2];
+    labelPart = toneMatch[1]!.trim();
+  }
+
+  // actor 名チェック
+  const names = new Set(actors.map((a) => a.name));
+  if (!names.has(from)) {
+    errors.push({ line: l.lineNo, message: `"${from}" が登場人物にいません`, hint: `登場人物: に "- ${from}" を追加` });
+  }
+  if (!names.has(to)) {
+    errors.push({ line: l.lineNo, message: `"${to}" が登場人物にいません`, hint: `登場人物: に "- ${to}" を追加` });
+  }
+
+  return { no, from, to, label: labelPart, sub, tone, pos: { line: l.lineNo } };
+}
+
+type ParseAnimResult = { anim: DslAnimate; nextIndex: number };
+
+function parseAnimate(lines: Line[], startIdx: number, errors: DslError[]): ParseAnimResult {
+  const states: DslState[] = [];
+  const phases: DslPhase[] = [];
+  const anim: DslAnimate = { states, phases, pos: { line: startIdx + 1 } };
+
+  let i = startIdx;
+  while (i < lines.length) {
+    const l = lines[i]!;
+    if (isBlank(l)) { i += 1; continue; }
+    // animate ブロックは indent > 0 が前提、 indent=0 なら top-level に戻る
+    if (l.indent === 0) break;
+
+    const kv = splitKv(l.trimmed);
+    if (kv) {
+      // kv[0] は "ステップ「送信」 1.5 秒" のような形 もあり得るので prefix 一致で resolve
+      // 「ステップ」 「step」 で始まる → "step"、 それ以外は exact match
+      let sub: ReturnType<typeof resolveAnimSubkey> = null;
+      const head = kv[0].trim();
+      if (/^(ステップ|step|STEP)/i.test(head)) sub = "step";
+      else sub = resolveAnimSubkey(head);
+      if (sub === "state") {
+        // "状態: 残高 = 100"
+        const m = kv[1].match(/^(.+?)\s*=\s*(.+)$/);
+        if (!m) {
+          errors.push({ line: l.lineNo, message: `状態 書式エラー: "${kv[1]}"`, hint: "`状態: <名前> = <初期値>`" });
+        } else {
+          const name = m[1]!.trim();
+          const raw = m[2]!.trim();
+          const num = parseFloat(raw);
+          const initial = isNaN(num) ? raw.replace(/^["']|["']$/g, "") : num;
+          states.push({ name, initial, pos: { line: l.lineNo } });
+        }
+        i += 1; continue;
+      }
+      if (sub === "step") {
+        // "ステップ「送信」 1.5 秒" or "step \"submit\" 1.5s"
+        // kv[0] には keyword + 「name」 + duration、 kv[1] は空 (`ステップ「送信」 1.5 秒:` の場合)
+        // ただし resolveAnimSubkey は kv[0] の最初の単語 (ステップ) だけ見るので、
+        // 残りは kv[0] 全体から keyword を除去して name + duration を抽出する。
+        const afterKeyword = kv[0]
+          .replace(/^(ステップ|step|STEP)\s*/i, "")
+          .trim();
+        const nameMatch = afterKeyword.match(/^[「"](.+?)[」"]\s*(.+)$/);
+        if (!nameMatch) {
+          errors.push({ line: l.lineNo, message: `ステップ 書式エラー: "${kv[0]}"`, hint: `\`ステップ「<名前>」 <時間>:\` 形式` });
+          i += 1; continue;
+        }
+        const phaseName = nameMatch[1]!;
+        const durStr = nameMatch[2]!.trim();
+        const durMs = parseDuration(durStr);
+        if (durMs === null) {
+          errors.push({ line: l.lineNo, message: `時間 解釈不能: "${durStr}"`, hint: "`1.5 秒` / `1500ms` / `2s` 等" });
+          i += 1; continue;
+        }
+        const phase: DslPhase = { name: phaseName, durationMs: durMs, pos: { line: l.lineNo } };
+        // sub block を読む
+        i += 1;
+        const phaseBaseIndent = l.indent;
+        while (i < lines.length && (lines[i]!.indent > phaseBaseIndent || isBlank(lines[i]!))) {
+          if (!isBlank(lines[i]!)) {
+            applyPhaseSubLine(lines[i]!, phase, errors);
+          }
+          i += 1;
+        }
+        phases.push(phase);
+        continue;
+      }
+    }
+    i += 1;
+  }
+
+  return { anim, nextIndex: i };
+}
+
+function applyPhaseSubLine(l: Line, phase: DslPhase, errors: DslError[]): void {
+  const kv = splitKv(l.trimmed);
+  if (!kv) return;
+  const sub = resolveAnimSubkey(kv[0]);
+  if (sub === "highlight") {
+    phase.highlight = kv[1].split(",").map((s) => s.trim()).filter(Boolean);
+    return;
+  }
+  if (sub === "tween") {
+    // "残高: 100 → 90"
+    const rest = normalizeArrow(kv[1]);
+    const m = rest.match(/^(.+?)\s*:\s*([\d.]+)\s*→\s*([\d.]+)$/);
+    if (!m) {
+      errors.push({ line: l.lineNo, message: `遷移 書式エラー: "${kv[1]}"`, hint: "`遷移: <state>: <from> → <to>`" });
+      return;
+    }
+    phase.tweens = phase.tweens ?? [];
+    phase.tweens.push({
+      state: m[1]!.trim(),
+      from: parseFloat(m[2]!),
+      to: parseFloat(m[3]!),
+      pos: { line: l.lineNo },
+    });
+    return;
+  }
+  if (sub === "set") {
+    // "ステータス: 完了"
+    const m = kv[1].match(/^(.+?)\s*:\s*(.+)$/);
+    if (!m) {
+      errors.push({ line: l.lineNo, message: `切替 書式エラー: "${kv[1]}"`, hint: "`切替: <state>: <値>`" });
+      return;
+    }
+    const raw = m[2]!.trim();
+    const num = parseFloat(raw);
+    const value = isNaN(num) ? raw : num;
+    phase.sets = phase.sets ?? [];
+    phase.sets.push({ state: m[1]!.trim(), value, pos: { line: l.lineNo } });
+    return;
+  }
+  if (sub === "body") {
+    phase.body = kv[1];
+    return;
+  }
+  if (sub === "badge") {
+    phase.badge = kv[1];
+    return;
+  }
+}