@cardenelabs/dragon 0.35.0 → 0.36.0

package/dist/{schema-BBWfniwH.d.cts → schema-9VLameDG.d.cts}

@@ -14,10 +14,22 @@ declare function resolvePalette(id?: string): Palette;
 /** 区画や箱を分ける色の役。灰 (slate) と硬貨 (coin) は分類の色として順に配らない。 */
 declare const COLOR_ORDER: readonly ["blue", "amber", "green", "violet", "rose"];
 type ColorKey = (typeof COLOR_ORDER)[number] | "slate" | "coin";
+/** 見せ方を決める字の大きさ。全体を枠に収めた時の箱の名前がこれを下回ると寄って追う。 */
+declare const READABLE_PX = 10.5;
+
+/**
+ * dragon記法の語 (#3137)。
+ *
+ * 行の種類は行の頭の英語の語で決まり、属性は `[<鍵>: <値>]` で書く。
+ * 語は英語だけで、原本の JSON が使う名前に揃え、記法と JSON で覚える語を 1 組にする。
+ *
+ * 言葉の型 (`NotationLang`) は、誤りの文と図の中の字の言葉を選ぶために持つ。
+ * 語が英語だけなので、記法の file から言葉は決めず、呼ぶ側が渡す。
+ *
+ * 型が欠けを止める。原本の JSON の値 (図の種類、運ぶ物、見せ方、名前の側) に語が無い時は、型の検査が落ちる。
+ */
 
 type NotationLang = "ja" | "en";
-/** 記法の言葉。最初の行の図の種類の語で決まり、決まらなければ `undefined` */
-declare function notationLanguage(notation: string): NotationLang | undefined;
 
 type Color = "blue" | "amber" | "green" | "violet" | "rose" | "slate" | "coin";
 interface Region {
@@ -109,4 +121,4 @@ interface CheckOptions {
 /** 原本の JSON を検査する。版が道具より新しいかは見ない (`readDiagram` が見る)。 */
 declare function validateDiagram(input: unknown, options?: CheckOptions): Checked;
 
-export { type Box as B, type CheckOptions as C, type Diagram as D, type FieldError as F, type LabelSide as L, type NotationLang as N, PALETTES as P, type Region as R, type Step as S, type Theme as T, type ViewMode as V, type ColorKey as a, type Carry as b, type Checked as c, type Color as d, DEFAULT_PALETTE as e, type DiagramEvent as f, type Palette as g, notationLanguage as n, resolvePalette as r, validateDiagram as v };
+export { type Box as B, type CheckOptions as C, type Diagram as D, type FieldError as F, type LabelSide as L, type NotationLang as N, PALETTES as P, READABLE_PX as R, type Step as S, type Theme as T, type ViewMode as V, type ColorKey as a, type Carry as b, type Checked as c, type Color as d, DEFAULT_PALETTE as e, type DiagramEvent as f, type Palette as g, type Region as h, resolvePalette as r, validateDiagram as v };

package/dist/{schema-BBWfniwH.d.ts → schema-9VLameDG.d.ts}

@@ -14,10 +14,22 @@ declare function resolvePalette(id?: string): Palette;
 /** 区画や箱を分ける色の役。灰 (slate) と硬貨 (coin) は分類の色として順に配らない。 */
 declare const COLOR_ORDER: readonly ["blue", "amber", "green", "violet", "rose"];
 type ColorKey = (typeof COLOR_ORDER)[number] | "slate" | "coin";
+/** 見せ方を決める字の大きさ。全体を枠に収めた時の箱の名前がこれを下回ると寄って追う。 */
+declare const READABLE_PX = 10.5;
+
+/**
+ * dragon記法の語 (#3137)。
+ *
+ * 行の種類は行の頭の英語の語で決まり、属性は `[<鍵>: <値>]` で書く。
+ * 語は英語だけで、原本の JSON が使う名前に揃え、記法と JSON で覚える語を 1 組にする。
+ *
+ * 言葉の型 (`NotationLang`) は、誤りの文と図の中の字の言葉を選ぶために持つ。
+ * 語が英語だけなので、記法の file から言葉は決めず、呼ぶ側が渡す。
+ *
+ * 型が欠けを止める。原本の JSON の値 (図の種類、運ぶ物、見せ方、名前の側) に語が無い時は、型の検査が落ちる。
+ */
 
 type NotationLang = "ja" | "en";
-/** 記法の言葉。最初の行の図の種類の語で決まり、決まらなければ `undefined` */
-declare function notationLanguage(notation: string): NotationLang | undefined;
 
 type Color = "blue" | "amber" | "green" | "violet" | "rose" | "slate" | "coin";
 interface Region {
@@ -109,4 +121,4 @@ interface CheckOptions {
 /** 原本の JSON を検査する。版が道具より新しいかは見ない (`readDiagram` が見る)。 */
 declare function validateDiagram(input: unknown, options?: CheckOptions): Checked;
 
-export { type Box as B, type CheckOptions as C, type Diagram as D, type FieldError as F, type LabelSide as L, type NotationLang as N, PALETTES as P, type Region as R, type Step as S, type Theme as T, type ViewMode as V, type ColorKey as a, type Carry as b, type Checked as c, type Color as d, DEFAULT_PALETTE as e, type DiagramEvent as f, type Palette as g, notationLanguage as n, resolvePalette as r, validateDiagram as v };
+export { type Box as B, type CheckOptions as C, type Diagram as D, type FieldError as F, type LabelSide as L, type NotationLang as N, PALETTES as P, READABLE_PX as R, type Step as S, type Theme as T, type ViewMode as V, type ColorKey as a, type Carry as b, type Checked as c, type Color as d, DEFAULT_PALETTE as e, type DiagramEvent as f, type Palette as g, type Region as h, resolvePalette as r, validateDiagram as v };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardenelabs/dragon",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "Dragon — 動く図を、人は行ごとの記法で、AI は JSON で書く。時系列図と構成図を段ごとに動かし、mp4・GIF・HTML・PNG に書き出す。",
   "license": "MIT",
   "author": "cardene777",
@@ -26,21 +26,32 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "dragon": "./dist/cli.js"
+    "dragon": "dist/cli.js"
   },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./fonts": {
       "import": "./dist/fonts.js",
       "require": "./dist/fonts.cjs"
     },
     "./export": {
-      "types": "./dist/export.d.ts",
-      "import": "./dist/export.js"
+      "import": {
+        "types": "./dist/export.d.ts",
+        "default": "./dist/export.js"
+      },
+      "require": {
+        "types": "./dist/export.d.cts",
+        "default": "./dist/export.cjs"
+      }
     }
   },
   "files": [
@@ -66,7 +77,8 @@
     "test": "cd ../.. && vitest run packages/dragon",
     "test:watch": "cd ../.. && vitest packages/dragon",
     "lint": "tsc --noEmit",
-    "prepublishOnly": "pnpm run typecheck && pnpm run test && pnpm run build"
+    "check:pack": "node scripts/check-pack.mjs",
+    "prepublishOnly": "pnpm run typecheck && pnpm run test && pnpm run build && pnpm run check:pack"
   },
   "peerDependencies": {
     "playwright-core": ">=1.49.0"

package/src/cli.ts

@@ -3,8 +3,8 @@
  * `dragon export <図の file>` の命令。原本の JSON (`.json`) か記法 (`.dragon`) を読み、mp4、GIF、HTML、PNG を書き出す。
  * 書き出した file の path を 1 行ずつ出す。
  *
- * 使い方の文と誤りの文は、図の中の字と同じ言葉で出す (#3003)。`--lang` を渡せばその言葉、無ければ記法の file の言葉、
- * JSON の原本と file を読む前の誤りは日本語。記法の行の誤りだけは、書き方の例が file の書き方に合うよう file の言葉で出す。
+ * 使い方の文と誤りの文は、図の中の字と同じ言葉で出す (#3003)。`--lang` を渡せばその言葉、無ければ日本語。
+ * dragon記法の語は英語だけで file から言葉が決まらないため、記法の file も JSON の原本と同じに扱う (#3137)。
  */
 import { readFileSync } from "node:fs";
 import { basename, extname, resolve } from "node:path";
@@ -12,7 +12,7 @@ import { parseArgs } from "node:util";
 import { type ExportFormat, exportDiagram, FORMATS } from "./export/index";
 import { PALETTES, type Theme } from "./look/values";
 import { parseNotation } from "./parser";
-import { type NotationLang, notationLanguage } from "./words";
+import type { NotationLang } from "./words";
 
 const OPTIONS = {
   out: { type: "string" },
@@ -54,7 +54,7 @@ const CLI_TEXT: Record<NotationLang, CliText> = {
       "  --width <px>       枠の幅。見せ方を選び、寄って見せる窓の幅になる",
       `  --palette <名前>   色味 (${PALETTE_NAMES})`,
       "  --theme <明暗>     light か dark",
-      "  --lang <言葉>      図の中の字と命令の文の言葉 (ja か en)。既定は記法の file の言葉で、JSON は ja",
+      "  --lang <言葉>      図の中の字と命令の文の言葉 (ja か en)。既定は ja",
       "  --fps <数>         mp4 の 1 秒のコマの数 (既定 30)",
       "  --gif-fps <数>     GIF の 1 秒のコマの数 (既定 10)",
       "  --format <形>      書き出す形を , で区切る (既定 mp4,gif,html,png)",
@@ -76,7 +76,7 @@ const CLI_TEXT: Record<NotationLang, CliText> = {
       "  --width <px>       Frame width. Picks the view and sets the window width when following",
       `  --palette <name>   Colors (${PALETTE_NAMES})`,
       "  --theme <mode>     light or dark",
-      "  --lang <lang>      Language of the diagram text and command messages (ja or en). Defaults to the notation file's language, and ja for JSON",
+      "  --lang <lang>      Language of the diagram text and command messages (ja or en). Defaults to ja",
       "  --fps <n>          Frames per second of the mp4 (default 30)",
       "  --gif-fps <n>      Frames per second of the GIF (default 10)",
       "  --format <list>    Formats to write, separated by , (default mp4,gif,html,png)",
@@ -147,8 +147,8 @@ function failedPath(error: unknown): string | undefined {
   return typeof error.path === "string" ? error.path : undefined;
 }
 
-/** 図の file を読む。記法の file はその言葉も返し、JSON の原本は言葉を持たない */
-function read(file: string, text: CliText): { diagram: unknown; lang?: NotationLang } {
+/** 図の file を読む。記法の行の誤りは `lang` の言葉で出す */
+function read(file: string, text: CliText, lang: NotationLang): unknown {
   let source: string;
   try {
     source = readFileSync(file, "utf8");
@@ -158,15 +158,14 @@ function read(file: string, text: CliText): { diagram: unknown; lang?: NotationL
   }
   if (extname(file) !== ".dragon") {
     try {
-      return { diagram: JSON.parse(source) };
+      return JSON.parse(source);
     } catch (error) {
       throw new Error(text.badJson(file, detail(error)));
     }
   }
-  const parsed = parseNotation(source);
+  const parsed = parseNotation(source, { lang });
   if (!parsed.ok) throw new Error(parsed.errors.map((e) => `${file}:${e.line} ${e.message}`).join("\n"));
-  const lang = notationLanguage(source);
-  return lang === undefined ? { diagram: parsed.diagram } : { diagram: parsed.diagram, lang };
+  return parsed.diagram;
 }
 
 async function main(argv: string[]): Promise<number> {
@@ -202,9 +201,9 @@ async function main(argv: string[]): Promise<number> {
   const width = number(values.width);
   const fps = number(values.fps);
   const gifFps = number(values["gif-fps"]);
-  const { diagram, lang: fileLang } = read(file, early);
-  // 渡した言葉を記法の file の言葉より先に使う。JSON の原本で渡さなければ、書き出しの既定 (日本語) になる
-  const lang = isLang(chosen) ? chosen : fileLang;
+  // 言葉は渡した物だけで決める。渡さなければ、書き出しの既定 (日本語) になる
+  const lang = isLang(chosen) ? chosen : undefined;
+  const diagram = read(file, early, lang ?? "ja");
   let result: Awaited<ReturnType<typeof exportDiagram>>;
   try {
     result = await exportDiagram(diagram, {

package/src/figure-text.ts

@@ -2,7 +2,7 @@
  * 描く部品が出す字 (#3001)。
  *
  * 図の原本は語を持たないので、呼ぶ側が言葉を渡す。渡さなければ日本語で出す。
- * 頁は頁の言葉を、`dragon export` は記法の file の言葉 (`--lang` を渡せばその言葉) を渡す。
+ * 頁は頁の言葉を、`dragon export` は `--lang` の言葉 (渡さなければ日本語) を渡す。
  */
 import type { NotationLang } from "./words";
 

package/src/index.ts

@@ -1,14 +1,14 @@
 /**
  * dragon の入口。
  *
- * 図の原本は JSON で、人は 1 行が 1 本の線になる記法で書く。記法と JSON は行き来でき、
+ * 図の原本は JSON で、人は行の頭の英語の語で行の種類を決める dragon記法で書く。記法と JSON は行き来でき、
  * JSON は JSON Schema 1 本で検査する。原本から図を描き、頁に置いて段ごとに動かす。
  * 頁に字を読み込むのは別の入口 `@cardenelabs/dragon/fonts`。
  */
 export { extractDiagrams, type Fence } from "./markdown";
 export { type LineError, type ParseOptions, type Parsed, parseNotation } from "./parser";
-export { type PrintOptions, printNotation } from "./printer";
-export { type NotationLang, notationLanguage } from "./words";
+export { printNotation } from "./printer";
+export type { NotationLang } from "./words";
 export {
   type Box,
   type Carry,
@@ -27,7 +27,7 @@ export {
 export { FORMAT_VERSION, type Migrated, migrateFile, type Read, readDiagram } from "./version";
 export type { Layout } from "./layout/scene";
 export { FONTS } from "./look/fonts";
-export { DEFAULT_PALETTE, type Palette, PALETTES, resolvePalette, type Theme } from "./look/values";
+export { DEFAULT_PALETTE, type Palette, PALETTES, READABLE_PX, resolvePalette, type Theme } from "./look/values";
 export { mountDiagram, type Player } from "./player";
 export { type Rendered, type RenderOptions, renderDiagram } from "./render/svg";
 export type { Timeline } from "./timeline";

package/src/look/values.ts

@@ -97,8 +97,16 @@ export const LOOK = {
   stroke: { hair: 1, edge: 1.7, edgeOn: 2.25, arrow: 1.5, flow: 1.3, halo: 7, on: 1.75, glyph: 2, lifeline: 1.2, envelope: 1.5, badgeRing: 1.5 },
   shadow: { near: 0.8, far: 4, nearY: 1, farY: 3 },
   mini: { w: 168, pad: 8, title: 14, inset: 12, radius: 10 },
-  /** 寄って追う見せ方の窓の高さの、幅に対する割合と下限 */
-  follow: { aspect: 0.75, minH: 320, ease: 0.6 },
+  /**
+   * 寄って追う見せ方の窓の高さの、幅に対する割合と下限。
+   * `fitMinH` は見える高さに収める時 (#3047) の窓の高さの下限で、これより低い枠では収めずに枠の中で送る。
+   * `narrow` は縦長の全体図を出す枠の幅の下限で、これより狭い枠 (携帯の幅) では全体図を出さずに窓へ幅を渡す (#3055)。
+   * `badgeRoom` は番号の丸が窓から外れる段で窓を寄せ直す時に、丸の周りに空ける幅 (#3046)。
+   * `headRoom` は時系列図の図の頭の箱の下端から、窓に線を見せ始める所までの幅 (#3118)。
+   * `head` は時系列図の窓の上端に貼る頭の列の頭の箱で、アイコンを外した名前と下の字の 2 段 (#3120)。
+   * `pad` は頭の列の上下の余白、`h` は箱の高さ、`nameY` と `subY` は箱の上端から名前と下の字の基準線まで
+   */
+  follow: { aspect: 0.75, minH: 320, fitMinH: 160, ease: 0.6, narrow: 440, badgeRoom: 8, headRoom: 10, head: { pad: 8, h: 40, nameY: 17, subY: 31 } },
   /** 色を混ぜる割合 (%) */
   mix: { icon: 14, regionIcon: 16, regionIconEdge: 34, cap: 12, capEdge: 42, badgePast: 14, badgePastEdge: 70, mini: 62, miniBand: 16, miniBandEdge: 36, view: 6 },
   /** 字の並びの基準線を、置きたい高さの真ん中からどれだけ下げるか */
@@ -106,8 +114,12 @@ export const LOOK = {
   /** 浮いて出る物が下から上がる長さと、弾んで出る物の始まりの大きさ */
   rise: 5,
   popFrom: 0.4,
-  /** 動きを嫌わない人の頁の部品 */
-  player: { gap: 10, radius: 12, button: 36, hidden: 1, focus: 2 },
+  /**
+   * 動きを嫌わない人の頁の部品。
+   * `narrow` は段の本文の帯を横 1 列に並べる帯の中身の幅の下限で、これより狭い帯 (携帯の幅) では題と本文を釦と番号の段の下に置く (#3057、#3069)。
+   * `touch` はその狭い帯で段を送る釦の縦横で、指で押せる大きさにする (#3069)
+   */
+  player: { gap: 10, radius: 12, button: 36, touch: 44, hidden: 1, focus: 2, narrow: 440 },
 } as const;
 
 /** 動きの長さ (秒)。 */

package/src/messages.ts

@@ -1,119 +1,197 @@
 /**
- * 記法の誤りの文 (#2997)。
+ * dragon記法の誤りの文 (#2997、#3137)。
  *
- * 誤りの文は file の言葉で出す。file の言葉は最初の行の図の種類の語で決まり、
- * 最初の行が読めず決まらない時は、呼ぶ側が渡した言葉 (渡さなければ日本語) で出す。
- * 文の中の記法の語は語の表から引き、表と文で語が食い違わないようにする。
+ * 記法の語は英語だけで file から言葉が決まらないため、誤りの文は呼ぶ側が渡した言葉
+ * (渡さなければ日本語) で出す。文の中の記法の語は語の表から引き、表と文で語が食い違わないようにする。
  */
 import { COLORS } from "./schema";
-import { type NotationLang, type WordGroup, type WORDS, wordOf } from "./words";
+import { CARRIES, HEADS, KINDS, type NotationLang, SIDES, VIEWS } from "./words";
+
+/** 新しい形のどの行の書き方を示すか。今の形の行に当たった時に、誤りの文が書き方を示す */
+export type Shape = "sequence" | "architecture" | "group" | "box" | "strip" | "view" | "step" | "say" | "code" | "act" | "note" | "set";
 
 export interface Messages {
   noHead: string;
   badHead: string;
+  /** 今の形の `word` を書いた行。`shape` の行の書き方を示す */
+  oldForm: (word: string, shape: Shape) => string;
+  unknownHead: (word: string) => string;
   duplicate: (id: string) => string;
+  needsId: (word: string) => string;
+  badId: (id: string) => string;
+  afterId: string;
   undeclaredBox: (id: string) => string;
   noBody: (title: string) => string;
   emptyStepTitle: string;
   noBoxes: string;
   noSteps: string;
-  viewTwice: string;
-  badView: string;
-  stripTwice: string;
-  emptyStripField: string;
-  stepLineBeforeStep: string;
-  unreadableDeclaration: string;
-  emptyName: (id: string) => string;
-  badColor: string;
-  regionFirst: (id: string) => string;
-  badAttr: (raw: string) => string;
+  emptySay: string;
+  sayTwice: string;
   codeTwice: string;
+  emptyCode: string;
   declarationInStep: string;
-  emptySwap: string;
-  unreadableStepLine: string;
-  edgeShape: string;
-  carryTwice: string;
-  tagNeedsValue: string;
-  carryTakesNoValue: (key: string) => string;
+  stepLineBeforeStep: string;
+  nestedGroup: string;
+  strayEnd: string;
+  endTakesNothing: string;
+  unclosedGroup: (id: string) => string;
+  regionReopened: (id: string) => string;
+  emptyName: (id: string) => string;
+  stripTwice: string;
+  stripShape: string;
+  emptyStripField: string;
   stripUndeclared: string;
-  stripTagOnce: string;
   noSuchField: (field: string) => string;
   stripNeedsValue: string;
-  /** 違う言葉の語 `word` を書いた時。`own` はこの file の言葉の同じ役割の語 */
-  otherLanguageWord: (word: string, own: string) => string;
+  actShape: string;
+  noteShape: string;
+  edgeShape: string;
+  emptyLabel: string;
+  quoteUnclosed: string;
+  afterQuote: string;
+  attrUnclosed: string;
+  attrNoColon: (raw: string) => string;
+  attrNoValue: (key: string) => string;
+  attrTwice: (key: string) => string;
+  badAttr: (key: string, allowed: readonly string[]) => string;
+  badColor: string;
+  badView: string;
+  badCarry: string;
+  badSide: string;
+  carryTwice: string;
 }
 
+const list = (words: readonly string[]): string => words.join(" / ");
+
 const ja = (): Messages => {
-  const w = <G extends WordGroup>(group: G, value: keyof (typeof WORDS)[G]): string => wordOf(group, value, "ja");
+  const shapes: Record<Shape, string> = {
+    sequence: "sequence <題>",
+    architecture: "architecture <題>",
+    group: "group <名札> as <名前> [note: <添え書き>] から end まで",
+    box: "box <名札> as <名前> [note: <下の小さな字>]",
+    strip: "strip <題>: <欄>, <欄>",
+    view: "sequence <題> [view: follow]",
+    step: "step <段の題>",
+    say: "say <段の本文>",
+    code: "code <命令>",
+    act: "act <名札>: <処理の名前>",
+    note: "note <名札>: <下の小さな字>",
+    set: "set <欄>: <値> [tag: <札>]",
+  };
   return {
-    noHead: `最初の行に図の種類 (${w("kind", "sequence")} か ${w("kind", "architecture")}) と題を書く`,
-    badHead: `最初の行は ${w("kind", "sequence")} か ${w("kind", "architecture")} で始め、続けて題を書く`,
+    noHead: `最初の行に図の種類 (${list(KINDS)}) と題を書く`,
+    badHead: `最初の行は ${KINDS.join(" か ")} で始め、続けて題を書く`,
+    oldForm: (word, shape) => `${word} は今の形の書き方。新しい形では ${shapes[shape]} と書く`,
+    unknownHead: (word) => `${word} は行の頭に書けない。行は ${list(HEADS)} か、<名札> -> <名札> で始める`,
     duplicate: (id) => `${id} は既に宣言した名札`,
+    needsId: (word) => `${word} の後ろに名札を書く`,
+    badId: (id) => `${id} は名札に使えない。名札には空白と [ ] 「 」 = : を含めない`,
+    afterId: "名札の後ろには as <名前> か属性を書く",
     undeclaredBox: (id) => `${id} という箱は宣言していない`,
-    noBody: (title) => `段「${title}」に本文 (> で始まる行) が要る`,
-    emptyStepTitle: "段の見出し (#) に題を書く",
+    noBody: (title) => `段「${title}」に本文 (say の行) が要る`,
+    emptyStepTitle: "step の後ろに段の題を書く",
     noBoxes: "箱を 1 つ以上宣言する",
-    noSteps: "段 (# で始まる行) を 1 つ以上書く",
-    viewTwice: `${w("head", "view")}は 1 行だけ書く`,
-    badView: `${w("head", "view")}は ${w("view", "fixed")} か ${w("view", "follow")}`,
-    stripTwice: "中身の帯は 1 つだけ宣言する",
-    emptyStripField: "帯の欄の名前が空",
-    stepLineBeforeStep: "線や処理は段の見出し (#) の下に書く",
-    unreadableDeclaration: "読めない行。箱の宣言は <名札> = <名前>「<下の小さな字>」 の形で書く",
+    noSteps: "段 (step の行) を 1 つ以上書く",
+    emptySay: "say の後ろか、その下に字下げした行に段の本文を書く",
+    sayTwice: "1 つの段に say は 1 つまで。長い本文は say の下に字下げして続ける",
+    codeTwice: "1 つの段に code は 1 行まで",
+    emptyCode: "code の後ろに命令を書く",
+    declarationInStep: "group と box と strip は最初の step より前に書く",
+    stepLineBeforeStep: "線と say と code と act と note と set は step の下に書く",
+    nestedGroup: "group の中に group は書けない。先に end で閉じる",
+    strayEnd: "end の前に、閉じる group が無い",
+    endTakesNothing: "end の後ろには何も書かない",
+    unclosedGroup: (id) => `group ${id} を end で閉じていない`,
+    regionReopened: (id) => `group ${id} は宣言済み。もう一度開く時は group ${id} だけを書き、名前と属性は最初の宣言に書く`,
     emptyName: (id) => `${id} の名前が空`,
-    badColor: `${w("attr", "color")}は ${COLORS.join(" / ")} のどれか`,
-    regionFirst: (id) => `${w("attr", "region")} ${id} を先に宣言する`,
-    badAttr: (raw) => `[${raw}] は書けない指定`,
-    codeTwice: "1 つの段に命令 (` で囲んだ行) は 1 行まで",
-    declarationInStep: "箱の宣言は最初の段の見出し (#) より前に書く",
-    emptySwap: "「」の中に書き換える字を書く",
-    unreadableStepLine: "読めない行。線は <名札> -> <名札> : <線の名前>、処理は <名札> : <処理の名前> の形で書く",
-    edgeShape: "線は <名札> -> <名札> : <線の名前> の形で書く",
-    carryTwice: "運ぶ物は 1 本の線に 1 つまで",
-    tagNeedsValue: `${w("carry", "tag")}には値を書く ([${w("carry", "tag")} <値>])`,
-    carryTakesNoValue: (key) => `[${key}] には値を書かない`,
-    stripUndeclared: `帯の値を書く前に、帯を宣言する (${w("head", "strip")} <題> = <欄>, <欄>)`,
-    stripTagOnce: "帯の札は 1 つまで",
-    noSuchField: (field) => `${field} という欄は帯に無い`,
-    stripNeedsValue: "帯の欄には = <値> か [<札>] を書く",
-    otherLanguageWord: (word, own) => `この図は日本語の語で書く。${word} ではなく ${own} と書く`,
+    stripTwice: "strip は 1 つだけ宣言する",
+    stripShape: "strip は strip <題>: <欄>, <欄> の形で書く",
+    emptyStripField: "strip の欄の名前が空",
+    stripUndeclared: "set を書く前に、strip <題>: <欄>, <欄> で帯を宣言する",
+    noSuchField: (field) => `${field} という欄は strip に無い`,
+    stripNeedsValue: "set は set <欄>: <値> か set <欄> [tag: <札>] の形で書く",
+    actShape: "act は act <名札>: <処理の名前> の形で書く",
+    noteShape: "note は note <名札>: <下の小さな字> の形で書く",
+    edgeShape: "線は <名札> -> <名札>: <線の名前> [<属性>] の形で書く",
+    emptyLabel: "線の : の後ろに線の名前を書く。名前を書かない時は : も書かない",
+    quoteUnclosed: '" で始めた字を " で閉じていない',
+    afterQuote: '" で閉じた字の後ろには、属性か次の , だけを書く',
+    attrUnclosed: "属性は [ で始めて ] で閉じ、行の終わりに置く",
+    attrNoColon: (raw) => `[${raw}] は書けない。属性は [<鍵>: <値>] の形で書く`,
+    attrNoValue: (key) => `${key}: の後ろに値を書く`,
+    attrTwice: (key) => `${key} は 1 つの行に 1 つまで`,
+    badAttr: (key, allowed) => `${key} はこの行に書けない属性。書けるのは ${list(allowed)}`,
+    badColor: `color は ${list(COLORS)} のどれか`,
+    badView: `view は ${list(VIEWS)} のどれか`,
+    badCarry: `carry は ${list(CARRIES)} のどれか。札は tag: <値> で書く`,
+    badSide: `side は ${list(SIDES)} のどれか`,
+    carryTwice: "運ぶ物は 1 本の線に 1 つまで。carry と tag は一緒に書かない",
   };
 };
 
 const en = (): Messages => {
-  const w = <G extends WordGroup>(group: G, value: keyof (typeof WORDS)[G]): string => wordOf(group, value, "en");
+  const shapes: Record<Shape, string> = {
+    sequence: "sequence <title>",
+    architecture: "architecture <title>",
+    group: "group <id> as <name> [note: <note>] through end",
+    box: "box <id> as <name> [note: <caption>]",
+    strip: "strip <title>: <field>, <field>",
+    view: "sequence <title> [view: follow]",
+    step: "step <step title>",
+    say: "say <step body>",
+    code: "code <command>",
+    act: "act <id>: <action>",
+    note: "note <id>: <caption>",
+    set: "set <field>: <value> [tag: <tag>]",
+  };
   return {
-    noHead: `Write the diagram kind (${w("kind", "sequence")} or ${w("kind", "architecture")}) and a title on the first line`,
-    badHead: `Start the first line with ${w("kind", "sequence")} or ${w("kind", "architecture")}, followed by the title`,
+    noHead: `Write the diagram kind (${list(KINDS)}) and a title on the first line`,
+    badHead: `Start the first line with ${KINDS.join(" or ")}, followed by the title`,
+    oldForm: (word, shape) => `${word} is the old notation. Write ${shapes[shape]} instead`,
+    unknownHead: (word) => `A line cannot start with ${word}. Start a line with ${list(HEADS)}, or <id> -> <id>`,
     duplicate: (id) => `${id} is already declared`,
+    needsId: (word) => `Write an id after ${word}`,
+    badId: (id) => `${id} cannot be an id. An id has no spaces and none of [ ] 「 」 = :`,
+    afterId: "Write as <name> or attributes after the id",
     undeclaredBox: (id) => `No box named ${id} is declared`,
-    noBody: (title) => `Step "${title}" needs a body (a line starting with >)`,
-    emptyStepTitle: "Write a title after the step heading (#)",
+    noBody: (title) => `Step "${title}" needs a body (a say line)`,
+    emptyStepTitle: "Write a title after step",
     noBoxes: "Declare at least one box",
-    noSteps: "Write at least one step (a line starting with #)",
-    viewTwice: `Write ${w("head", "view")} only once`,
-    badView: `${w("head", "view")} is ${w("view", "fixed")} or ${w("view", "follow")}`,
-    stripTwice: `Declare only one ${w("head", "strip")}`,
-    emptyStripField: `A ${w("head", "strip")} field name is empty`,
-    stepLineBeforeStep: "Write lines and actions under a step heading (#)",
-    unreadableDeclaration: 'Cannot read this line. Declare a box as <id> = <name> "<caption>"',
+    noSteps: "Write at least one step (a step line)",
+    emptySay: "Write the step body after say, or on indented lines below it",
+    sayTwice: "A step takes one say. Continue a long body on indented lines below it",
+    codeTwice: "A step takes at most one code line",
+    emptyCode: "Write the command after code",
+    declarationInStep: "Write group, box and strip before the first step",
+    stepLineBeforeStep: "Write lines, say, code, act, note and set under a step",
+    nestedGroup: "A group cannot hold another group. Close it with end first",
+    strayEnd: "There is no group for this end to close",
+    endTakesNothing: "Write nothing after end",
+    unclosedGroup: (id) => `group ${id} is not closed with end`,
+    regionReopened: (id) => `group ${id} is already declared. To open it again, write only group ${id}; put the name and attributes on the first one`,
     emptyName: (id) => `${id} has an empty name`,
-    badColor: `${w("attr", "color")} is one of ${COLORS.join(" / ")}`,
-    regionFirst: (id) => `Declare ${w("attr", "region")} ${id} first`,
-    badAttr: (raw) => `[${raw}] cannot be written here`,
-    codeTwice: "A step takes at most one command (a line in backticks)",
-    declarationInStep: "Declare boxes before the first step heading (#)",
-    emptySwap: 'Write the new caption inside "…"',
-    unreadableStepLine: "Cannot read this line. Write a line as <id> -> <id> : <label>, or an action as <id> : <action>",
-    edgeShape: "Write a line as <id> -> <id> : <label>",
-    carryTwice: "A line carries at most one thing",
-    tagNeedsValue: `${w("carry", "tag")} needs a value ([${w("carry", "tag")} <value>])`,
-    carryTakesNoValue: (key) => `[${key}] takes no value`,
-    stripUndeclared: `Declare the ${w("head", "strip")} before writing its values (${w("head", "strip")} <title> = <field>, <field>)`,
-    stripTagOnce: `A ${w("head", "strip")} value takes at most one tag`,
-    noSuchField: (field) => `The ${w("head", "strip")} has no field named ${field}`,
-    stripNeedsValue: `Write = <value> or [<tag>] after the ${w("head", "strip")} field`,
-    otherLanguageWord: (word, own) => `This diagram uses English words. Write ${own} instead of ${word}`,
+    stripTwice: "Declare only one strip",
+    stripShape: "Write a strip as strip <title>: <field>, <field>",
+    emptyStripField: "A strip field name is empty",
+    stripUndeclared: "Declare the strip as strip <title>: <field>, <field> before writing set",
+    noSuchField: (field) => `The strip has no field named ${field}`,
+    stripNeedsValue: "Write set as set <field>: <value> or set <field> [tag: <tag>]",
+    actShape: "Write act as act <id>: <action>",
+    noteShape: "Write note as note <id>: <caption>",
+    edgeShape: "Write a line as <id> -> <id>: <label> [<attributes>]",
+    emptyLabel: "Write the label after the : of a line, or leave out the : as well",
+    quoteUnclosed: 'A value that starts with " is not closed with "',
+    afterQuote: 'After a value closed with ", write only attributes or the next ,',
+    attrUnclosed: "Start attributes with [, close them with ], and put them at the end of the line",
+    attrNoColon: (raw) => `[${raw}] cannot be read. Write an attribute as [<key>: <value>]`,
+    attrNoValue: (key) => `Write a value after ${key}:`,
+    attrTwice: (key) => `Write ${key} only once on a line`,
+    badAttr: (key, allowed) => `${key} cannot be written on this line. Write ${list(allowed)}`,
+    badColor: `color is one of ${list(COLORS)}`,
+    badView: `view is one of ${list(VIEWS)}`,
+    badCarry: `carry is one of ${list(CARRIES)}. Write a tag as tag: <value>`,
+    badSide: `side is one of ${list(SIDES)}`,
+    carryTwice: "A line carries one thing. Do not write carry and tag together",
   };
 };