@cardenelabs/dragon 0.34.0 → 0.35.0

package/src/parser.ts

@@ -1,354 +1,386 @@
 /**
- * Text DSL parser
- * 入力: docs/cdl/text-dsl-spec.md 準拠の箇条書きテキスト
- * 出力: DslDocument AST or DslError[]
+ * 人が書く記法を、図の原本の JSON へ変える。
+ *
+ * 記法は 1 行が 1 本の線になる行ごとの文で、最初の段の見出しより前に図の種類と題と箱を宣言し、
+ * 段ごとに見出し (`#`) と本文 (`>`) の下へ、その段で起きることを起きる順に 1 行ずつ並べる。
+ *
+ *   時系列図 <題>
+ *   見せ方 <止める か 寄る>                            書かなければ字の大きさで選ぶ
+ *   区画 <名札> = <名前>「<添え書き>」 [色 <色>] [印 <印>]
+ *   <名札> = <名前>「<下の小さな字>」 [色 <色>] [印 <印>] [区画 <名札>]
+ *   帯 <題> = <欄>, <欄>
+ *   # <段の題>
+ *   > <段の本文>
+ *   `<段で打つ命令>`
+ *   <名札> -> <名札> : <線の名前> [札 <値>] [名前 上]   線。運ぶ物を書かなければ封筒が走る
+ *   <名札> : <処理の名前>                              箱の中の処理
+ *   <名札>「<字>」                                     箱の下の小さな字の書き換え
+ *   帯 <欄> = <値> [<札>]                              中身の帯の値
+ *
+ * 語は英語でも書ける (#2997)。`sequence` / `architecture` で始めた file は、語を `words.ts` の表の
+ * 英語の語で書き、`「…」` の代わりに `"…"` でも囲める。1 つの file の言葉は最初の行の図の種類の語で
+ * 決まり、違う言葉の語を書いた行は誤りにする。誤りの文も file の言葉で出す。
+ *
+ * 行の頭の語と同じ綴りの名札 (`帯` や `strip`) も書ける。行の頭の語と名札は行の形で見分け、
+ * 名札の次に `->` か `:` か `=` か囲みが来る行は箱の行と読む。
+ *
+ * 誤りは最初の 1 つで止め、行と列を示す。
  */
+import { type Messages, messagesFor } from "./messages";
+import { type Box, type Carry, type Color, COLORS, type Diagram, type DiagramEvent, type LabelSide, type Region, type Step, type ViewMode } from "./schema";
+import { columnOf, type SourceLine, tokenize } from "./tokenize";
+import { FORMAT_VERSION } from "./version";
+import { languageOf, type NotationLang, otherLang, valueOf, wordOf, type WORDS } from "./words";
 
-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";
+export interface LineError {
+  line: number;
+  column: number;
+  message: string;
+}
 
-type Line = { raw: string; trimmed: string; indent: number; lineNo: number };
+export type Parsed = { ok: true; diagram: Diagram } | { ok: false; errors: LineError[] };
 
-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;
+export interface ParseOptions {
+  /** 最初の行が読めず file の言葉が決まらない時に、誤りの文に使う言葉。既定は日本語 */
+  lang?: NotationLang;
 }
 
-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,
-    };
-  });
+class NotationError extends Error {
+  constructor(
+    readonly line: number,
+    readonly column: number,
+    message: string,
+  ) {
+    super(message);
+  }
 }
 
-function isBlank(l: Line): boolean {
-  return l.trimmed === "";
-}
+const fail = (source: SourceLine, index: number, message: string): NotationError =>
+  new NotationError(source.line, columnOf(source, index), message);
 
-/** "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()];
+/** `[鍵 値]` の指定。`raw` は括弧の中身そのまま、`at` は `[` の位置。 */
+interface Attr {
+  raw: string;
+  key: string;
+  value: string;
+  at: number;
 }
 
-/** 行の "- 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() };
+/** 行の `start` から後ろの終わりに並ぶ `[...]` を外す。`end` は残った字の終わり。 */
+function trailingAttrs(source: SourceLine, start: number): { end: number; attrs: Attr[] } {
+  const attrs: Attr[] = [];
+  let end = source.text.length;
+  for (;;) {
+    const found = /\s*\[([^[\]]*)\]$/.exec(source.text.slice(start, end));
+    if (!found) break;
+    const raw = (found[1] ?? "").trim();
+    const [key = "", ...words] = raw.split(/\s+/);
+    attrs.unshift({ raw, key, value: words.join(" "), at: start + found.index + found[0].indexOf("[") });
+    end = start + found.index;
+  }
+  return { end, attrs };
 }
 
-/**
- * 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;
+const escape = (word: string): string => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
-  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;
-      }
-    }
+/** 字を囲む形。日本語の語の file は「」だけ、英語の語の file は「」と "" を読む */
+const QUOTES: Record<NotationLang, readonly (readonly [string, string])[]> = {
+  ja: [["「", "」"]],
+  en: [
+    ["「", "」"],
+    ['"', '"'],
+  ],
+};
 
-    // 知らない top-level 行はスキップ (warning に降格、 ignore)
-    i += 1;
+/** `<名前>「<添え書き>」` を名前と添え書きに分ける。 */
+function nameAndNote(text: string, lang: NotationLang): { name: string; note?: string } {
+  for (const [open, close] of QUOTES[lang]) {
+    const found = new RegExp(`^(.*?)\\s*${escape(open)}(.*)${escape(close)}$`).exec(text);
+    if (found) return { name: (found[1] ?? "").trim(), note: found[2] ?? "" };
   }
+  return { name: text.trim() };
+}
 
-  // 必須項目チェック
-  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 };
+/** `<名札>「<字>」` の書き換えの行。名札と字の位置を返す */
+function swapLine(text: string, lang: NotationLang): RegExpExecArray | null {
+  const opens = QUOTES[lang].map(([o]) => escape(o)).join("");
+  for (const [open, close] of QUOTES[lang]) {
+    const found = new RegExp(`^([^\\s${opens}]+)\\s*${escape(open)}(.*)${escape(close)}$`, "d").exec(text);
+    if (found) return found;
+  }
+  return null;
+}
 
+/**
+ * 1 つの言葉の、行の頭の語で始まる行の形。
+ * `reading` は読んでいる file の言葉で、帯の値の行から外す箱の行 (名札の次に囲みが来る行) の形を決める。
+ */
+function headShapes(lang: NotationLang, reading: NotationLang) {
+  const head = (key: keyof typeof WORDS.head): string => escape(wordOf("head", key, lang));
+  const opens = QUOTES[reading].map(([open]) => `|${escape(open)}`).join("");
   return {
-    ok: true,
-    doc: {
-      title: title!,
-      type: type!,
-      actors,
-      flow: steps,
-      animate,
-      pos: { line: 1 },
-    },
+    view: new RegExp(`^${head("view")}\\s+(\\S+)$`),
+    strip: new RegExp(`^${head("strip")}\\s+(.+?)\\s*=\\s*(.+)$`),
+    region: new RegExp(`^${head("region")}\\s+([^\\s=]+)\\s*=\\s*`, "d"),
+    // 空白を全部読んでから次の字を見る (`\s` を外すと、空白 2 つの `帯  -> 受け手` を帯の値と読む)
+    stripValue: new RegExp(`^${head("strip")}\\s+(?!\\s|->|:|=${opens})`),
   };
 }
 
-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 } };
+interface Building {
+  source: SourceLine;
+  title: string;
+  body: string[];
+  code?: string;
+  events: DiagramEvent[];
 }
 
-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();
-    }
-  }
+function parseLines(lines: SourceLine[], fallback: NotationLang): Diagram {
+  const [head, ...rest] = lines;
+  if (!head) throw new NotationError(1, 1, messagesFor(fallback).noHead);
+  const found = languageOf(head.text);
+  const m: Messages = messagesFor(found ?? fallback);
+  const header = /^(\S+)\s+(.+)$/.exec(head.text);
+  const kind = found && valueOf("kind", header?.[1] ?? "", found);
+  if (!found || !header || !kind) throw fail(head, 0, m.badHead);
+  const lang: NotationLang = found;
+  const title = header[2] ?? "";
 
-  // 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();
-  }
+  const other = otherLang(lang);
+  const own = headShapes(lang, lang);
+  const foreign = headShapes(other, lang);
+  /** 違う言葉の語を書いた行の誤り。`group` の役割の、この file の言葉の語を示す */
+  const foreignWord = <G extends keyof typeof WORDS>(source: SourceLine, at: number, group: G, word: string): NotationError =>
+    fail(source, at, m.otherLanguageWord(word, wordOf(group, valueOf(group, word, other) as keyof (typeof WORDS)[G], lang)));
 
-  // 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}" を追加` });
-  }
+  const regions: Region[] = [];
+  const boxes: Box[] = [];
+  const ids = new Set<string>();
+  let strip: { title: string; fields: string[] } | undefined;
+  let view: ViewMode | undefined;
+  const steps: Step[] = [];
+  let building: Building | undefined;
 
-  return { no, from, to, label: labelPart, sub, tone, pos: { line: l.lineNo } };
-}
+  const declare = (source: SourceLine, id: string, at: number): void => {
+    if (ids.has(id)) throw fail(source, at, m.duplicate(id));
+    ids.add(id);
+  };
+  const boxAt = (source: SourceLine, id: string, at: number): string => {
+    if (!boxes.some((box) => box.id === id)) throw fail(source, at, m.undeclaredBox(id));
+    return id;
+  };
+  const finish = (): void => {
+    if (!building) return;
+    if (building.body.length === 0) throw fail(building.source, 0, m.noBody(building.title));
+    steps.push({
+      title: building.title,
+      body: building.body.join("\n"),
+      ...(building.code !== undefined ? { code: building.code } : {}),
+      events: building.events,
+    });
+  };
 
-type ParseAnimResult = { anim: DslAnimate; nextIndex: number };
+  for (const source of rest) {
+    const text = source.text;
+    if (text.startsWith("#")) {
+      finish();
+      const stepTitle = text.slice(1).trim();
+      if (stepTitle === "") throw fail(source, 0, m.emptyStepTitle);
+      building = { source, title: stepTitle, body: [], events: [] };
+      continue;
+    }
+    if (!building) {
+      parseDeclaration(source);
+      continue;
+    }
+    building.events.push(...parseStepLine(source, building));
+  }
+  finish();
 
-function parseAnimate(lines: Line[], startIdx: number, errors: DslError[]): ParseAnimResult {
-  const states: DslState[] = [];
-  const phases: DslPhase[] = [];
-  const anim: DslAnimate = { states, phases, pos: { line: startIdx + 1 } };
+  if (boxes.length === 0) throw fail(head, 0, m.noBoxes);
+  if (steps.length === 0) throw fail(head, 0, m.noSteps);
 
-  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;
+  return {
+    version: FORMAT_VERSION,
+    kind,
+    title,
+    ...(view ? { view } : {}),
+    ...(regions.length > 0 ? { regions } : {}),
+    boxes,
+    ...(strip ? { strip } : {}),
+    steps,
+    ...(kind === "sequence" ? { sequence: { lifelines: boxes.map((box) => box.id) } } : {}),
+  };
 
-    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;
+  function parseDeclaration(source: SourceLine): void {
+    const text = source.text;
+    const viewDecl = own.view.exec(text);
+    if (viewDecl) {
+      if (view) throw fail(source, 0, m.viewTwice);
+      const word = viewDecl[1] ?? "";
+      const at = text.indexOf(word);
+      const chosen = valueOf("view", word, lang);
+      if (!chosen) {
+        if (valueOf("view", word, other) !== undefined) throw foreignWord(source, at, "view", word);
+        throw fail(source, at, m.badView);
       }
-      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;
+      view = chosen;
+      return;
+    }
+    const stripDecl = own.strip.exec(text);
+    if (stripDecl) {
+      if (strip) throw fail(source, 0, m.stripTwice);
+      const fields = (stripDecl[2] ?? "").split(",").map((field) => field.trim());
+      if (fields.some((field) => field === "")) throw fail(source, 0, m.emptyStripField);
+      strip = { title: stripDecl[1] ?? "", fields };
+      return;
+    }
+    const regionDecl = own.region.exec(text);
+    const boxDecl = regionDecl ? undefined : /^([^\s=]+)\s*=(?!>)\s*/d.exec(text);
+    const decl = regionDecl ?? boxDecl;
+    if (!decl?.indices?.[1]) {
+      if (foreign.view.test(text) || foreign.strip.test(text) || foreign.region.test(text)) {
+        throw foreignWord(source, 0, "head", text.split(/\s+/)[0] ?? "");
       }
+      if (looksLikeStepLine(text, lang)) throw fail(source, 0, m.stepLineBeforeStep);
+      throw fail(source, 0, m.unreadableDeclaration);
     }
-    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>`" });
+    const id = decl[1] ?? "";
+    declare(source, id, decl.indices[1][0]);
+    const { end, attrs } = trailingAttrs(source, decl[0].length);
+    const { name, note } = nameAndNote(text.slice(decl[0].length, end), lang);
+    if (name === "") throw fail(source, decl[0].length, m.emptyName(id));
+    const look: { color?: Color; icon?: string; region?: string } = {};
+    for (const attr of attrs) {
+      const key = valueOf("attr", attr.key, lang);
+      if (key === "color") {
+        if (!COLORS.includes(attr.value as Color)) throw fail(source, attr.at, m.badColor);
+        look.color = attr.value as Color;
+      } else if (key === "icon" && attr.value !== "") {
+        look.icon = attr.value;
+      } else if (key === "region" && !regionDecl) {
+        if (!regions.some((region) => region.id === attr.value)) throw fail(source, attr.at, m.regionFirst(attr.value));
+        look.region = attr.value;
+      } else {
+        if (valueOf("attr", attr.key, other) !== undefined) throw foreignWord(source, attr.at, "attr", attr.key);
+        throw fail(source, attr.at, m.badAttr(attr.raw));
+      }
+    }
+    if (regionDecl) {
+      regions.push({
+        id,
+        name,
+        ...(note !== undefined ? { note } : {}),
+        ...(look.color ? { color: look.color } : {}),
+        ...(look.icon ? { icon: look.icon } : {}),
+      });
       return;
     }
-    phase.tweens = phase.tweens ?? [];
-    phase.tweens.push({
-      state: m[1]!.trim(),
-      from: parseFloat(m[2]!),
-      to: parseFloat(m[3]!),
-      pos: { line: l.lineNo },
+    boxes.push({
+      id,
+      name,
+      ...(note !== undefined ? { sub: note } : {}),
+      ...(look.color ? { color: look.color } : {}),
+      ...(look.icon ? { icon: look.icon } : {}),
+      ...(look.region ? { region: look.region } : {}),
     });
-    return;
   }
-  if (sub === "set") {
-    // "ステータス: 完了"
-    const m = kv[1].match(/^(.+?)\s*:\s*(.+)$/);
-    if (!m) {
-      errors.push({ line: l.lineNo, message: `切替 書式エラー: "${kv[1]}"`, hint: "`切替: <state>: <値>`" });
-      return;
+
+  function parseStepLine(source: SourceLine, step: Building): DiagramEvent[] {
+    const text = source.text;
+    if (text.startsWith(">")) {
+      step.body.push(text.slice(1).trim());
+      return [];
+    }
+    const code = /^`(.*)`$/.exec(text);
+    if (code) {
+      if (step.code !== undefined) throw fail(source, 0, m.codeTwice);
+      step.code = code[1] ?? "";
+      return [];
+    }
+    if (own.stripValue.test(text)) return [parseStripValue(source)];
+    if (foreign.stripValue.test(text)) throw foreignWord(source, 0, "head", text.split(/\s+/)[0] ?? "");
+    if (text.includes("->")) return [parseEdge(source)];
+    if (/^[^\s=]+\s*=(?!>)/.test(text)) throw fail(source, 0, m.declarationInStep);
+    const swap = swapLine(text, lang);
+    if (swap?.indices?.[1]) {
+      const box = boxAt(source, swap[1] ?? "", swap.indices[1][0]);
+      if ((swap[2] ?? "") === "") throw fail(source, swap.indices[1][1], m.emptySwap);
+      return [{ type: "swap", box, text: swap[2] ?? "" }];
+    }
+    const action = /^([^\s:]+)\s*:\s*(.+)$/d.exec(text);
+    if (action?.indices?.[1]) return [{ type: "action", box: boxAt(source, action[1] ?? "", action.indices[1][0]), label: action[2] ?? "" }];
+    throw fail(source, 0, m.unreadableStepLine);
+  }
+
+  function parseEdge(source: SourceLine): DiagramEvent {
+    const { end, attrs } = trailingAttrs(source, 0);
+    const edge = /^([^\s:]+)\s*->\s*([^\s:]+)(?:\s*:\s*(.+))?$/d.exec(source.text.slice(0, end));
+    if (!edge?.indices?.[1] || !edge.indices[2]) throw fail(source, 0, m.edgeShape);
+    const from = boxAt(source, edge[1] ?? "", edge.indices[1][0]);
+    const to = boxAt(source, edge[2] ?? "", edge.indices[2][0]);
+    let carry: Carry | undefined;
+    let labelSide: LabelSide | undefined;
+    for (const attr of attrs) {
+      const kind = valueOf("carry", attr.key, lang);
+      const label = valueOf("attr", attr.key, lang) === "label";
+      if (kind !== undefined) {
+        if (carry) throw fail(source, attr.at, m.carryTwice);
+        if (kind === "tag") {
+          if (attr.value === "") throw fail(source, attr.at, m.tagNeedsValue);
+          carry = { kind, text: attr.value };
+        } else {
+          if (attr.value !== "") throw fail(source, attr.at, m.carryTakesNoValue(attr.key));
+          carry = { kind };
+        }
+      } else if (label && valueOf("side", attr.value, lang) !== undefined) {
+        labelSide = valueOf("side", attr.value, lang);
+      } else {
+        if (label && valueOf("side", attr.value, other) !== undefined) throw foreignWord(source, attr.at, "side", attr.value);
+        if (valueOf("carry", attr.key, other) !== undefined) throw foreignWord(source, attr.at, "carry", attr.key);
+        if (valueOf("attr", attr.key, other) !== undefined) throw foreignWord(source, attr.at, "attr", attr.key);
+        throw fail(source, attr.at, m.badAttr(attr.raw));
+      }
     }
-    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;
+    return {
+      type: "edge",
+      from,
+      to,
+      ...(edge[3] !== undefined ? { label: edge[3] } : {}),
+      carry: carry ?? { kind: "envelope" },
+      ...(labelSide ? { labelSide } : {}),
+    };
   }
-  if (sub === "body") {
-    phase.body = kv[1];
-    return;
+
+  function parseStripValue(source: SourceLine): DiagramEvent {
+    if (!strip) throw fail(source, 0, m.stripUndeclared);
+    const start = new RegExp(`^${escape(wordOf("head", "strip", lang))}\\s+`).exec(source.text)?.[0].length ?? 0;
+    const { end, attrs } = trailingAttrs(source, start);
+    if (attrs.length > 1) throw fail(source, attrs[1]?.at ?? 0, m.stripTagOnce);
+    const rest = source.text.slice(start, end);
+    const assigned = /^(.+?)\s*=\s*(.+)$/.exec(rest);
+    const field = (assigned ? assigned[1] : rest)?.trim() ?? "";
+    if (!strip.fields.includes(field)) throw fail(source, start, m.noSuchField(field));
+    const tag = attrs[0]?.raw;
+    if (!assigned && tag === undefined) throw fail(source, start, m.stripNeedsValue);
+    return {
+      type: "strip",
+      field,
+      ...(assigned ? { value: assigned[2] ?? "" } : {}),
+      ...(tag !== undefined ? { tag } : {}),
+    };
   }
-  if (sub === "badge") {
-    phase.badge = kv[1];
-    return;
+}
+
+function looksLikeStepLine(text: string, lang: NotationLang): boolean {
+  return text.startsWith(">") || text.startsWith("`") || text.includes("->") || swapLine(text, lang) !== null;
+}
+
+export function parseNotation(notation: string, options: ParseOptions = {}): Parsed {
+  try {
+    return { ok: true, diagram: parseLines(tokenize(notation), options.lang ?? "ja") };
+  } catch (error) {
+    if (!(error instanceof NotationError)) throw error;
+    return { ok: false, errors: [{ line: error.line, column: error.column, message: error.message }] };
   }
 }