@cardenelabs/dragon 0.7.0 → 0.8.0

package/src/v05/parser.ts

@@ -45,13 +45,22 @@ import type { NodeKind, Tone, EdgeStyle } from "@cardenelabs/cdl";
 import { TONES, NODE_KINDS } from "@cardenelabs/cdl";
 import { TONE_ALIAS } from "../keywords";
 import { parseRelativePos, orderByDependency } from "../relative-pos";
+import {
+  checkValueExpression,
+  isTriggerBody,
+  isValueName,
+  parseValueTriggerBody,
+  valueNameIssue,
+} from "../value-syntax";
 import type {
+  DslAxes,
   DslDocument,
   DslActor,
   DslActorNodeOverride,
   DslStep,
   DslAnimate,
   DslState,
+  DslValue,
   DslPhase,
   DslTween,
   DslSet,
@@ -66,6 +75,44 @@ export type V05ParseResult =
   | { ok: true; doc: DslDocument }
   | { ok: false; errors: DslError[] };
 
+/**
+ * 記法が受ける top-level の項目 (#1190)。
+ *
+ * 読めない行の案内と、記法一覧が全て載せているかの検査が、どちらもここを見る。 一覧に手で
+ * 書くと、項目を足した時に案内か一覧のどちらかが取り残される (実際に `states` / `values` が
+ * 一覧に 1 件も無い状態で放置されていた)。
+ */
+export const TOP_LEVEL_KEYS = [
+  "title", "type", "actors", "flow", "states", "values", "animation", "viewport", "lanes", "groups",
+  // 図全体を 1 箱にする図種で、 その箱の上に出す小見出し (#1247)
+  "eyebrow",
+  // 2 軸で仕分ける図の軸の名前 (#1251)
+  "axes",
+] as const;
+
+/**
+ * `lanes:` / `groups:` の 1 行を読む形 (#1241)。
+ *
+ * **id は英数字と下線に限らない**。 組み立て側は登場人物の名前から縦列 id を作るため、
+ * hyphen と日本語が入る (実測 = `type: state` で `lane-idle` / `lane-待機`、
+ * `type: swimlane` で `lane-sign-up`)。 英数字と下線だけを受けていた間、
+ * **自動で作られた縦列の幅や見出しを書き直す手段が無かった**。
+ *
+ * 受けるのは **組み立て側が作りうる字だけ** に絞る。 字と数と下線と hyphen。
+ *
+ * 「読み取りを壊す字以外は何でも」 にすると、`lane-idle,` のような書き間違いが
+ * **別の縦列として通り**、書いた幅が黙って効かなくなる (Round 1 の指摘、実測)。
+ *
+ * **非 ASCII をまとめて許すのも広すぎる** (Round 2 の指摘)。 全角の読点や感嘆符、絵文字まで
+ * 通ってしまう (実測 = `lane-idle、` / `lane-idle！` / `lane-idle🙂` が受かった)。
+ * 字 (`\p{L}`) と数 (`\p{N}`) だけを許せば、日本語の縦列 id は通しつつ句読点は外せる。
+ */
+const LANE_ID_ENTRY = /^([\p{L}\p{N}_-]+)\s*:\s*\{([^}]*)\}\s*$/u;
+
+function isTopLevelKey(key: string): key is (typeof TOP_LEVEL_KEYS)[number] {
+  return (TOP_LEVEL_KEYS as readonly string[]).includes(key);
+}
+
 /** 受け付ける図種。 記法一覧はここを見る。 */
 export const PRESET_TYPES: ReadonlySet<PresetType> = new Set([
   "sequence",
@@ -78,6 +125,12 @@ export const PRESET_TYPES: ReadonlySet<PresetType> = new Set([
   "gantt",
   "class",
   "pie",
+  "bar",
+  "line",
+  "funnel",
+  "tree",
+  "journey",
+  "quadrant",
   "c4",
   "mind",
 ]);
@@ -157,9 +210,14 @@ export function parseTextDslV05(src: string): V05ParseResult {
 
   let title: string | null = null;
   let type: PresetType | null = null;
+  let eyebrow: string | null = null;
+  let eyebrowLine = 0;
+  let axes: DslAxes | undefined = undefined;
+  let axesLine = 0;
   let actors: DslActor[] = [];
   const flow: DslStep[] = [];
   let animate: DslAnimate | undefined = undefined;
+  const values: DslValue[] = [];
   let viewport: DslViewport | undefined = undefined;
   let lanesMap: Record<string, DslLane> | undefined = undefined;
   let groupsMap: Record<string, DslGroup> | undefined = undefined;
@@ -172,11 +230,11 @@ export function parseTextDslV05(src: string): V05ParseResult {
       continue;
     }
     const head = matchTopHeader(line.trimmed);
-    if (!head) {
+    if (!head || !isTopLevelKey(head.key)) {
       errors.push({
         line: line.no,
         message: `unknown top-level key: "${line.trimmed}"`,
-        hint: "expected one of: title, type, actors, flow, states, animation, viewport, lanes, groups",
+        hint: `expected one of: ${TOP_LEVEL_KEYS.join(", ")}`,
       });
       i += 1;
       continue;
@@ -189,6 +247,15 @@ export function parseTextDslV05(src: string): V05ParseResult {
       i += 1;
       continue;
     }
+    if (head.key === "eyebrow") {
+      // 空で書いた形 (`eyebrow:`) は「書かなかった」 と同じにする。 空文字を残すと
+      // 描画側が中身のない帯を出す
+      const v = (head.value ?? "").trim();
+      eyebrow = v.length > 0 ? v : null;
+      eyebrowLine = line.no;
+      i += 1;
+      continue;
+    }
     if (head.key === "type") {
       const v = (head.value ?? "").trim().toLowerCase();
       if (!PRESET_TYPES.has(v as PresetType)) {
@@ -265,6 +332,36 @@ export function parseTextDslV05(src: string): V05ParseResult {
       i = next;
       continue;
     }
+    if (head.key === "values") {
+      // 1 行に詰める形 (`values: { a: "..." }` / `values: a: "..."`) は受けない。 式に `,` が
+      // 入る (`min({a}, {b})`) ため、 `states` が使う素朴な `,` 分割では式が壊れる。
+      //
+      // **`{` で始まるかを見てはいけない** (#1169)。 `values: a: "{b} + 1"` は `{` で始まらない
+      // ため判定を通り抜け、 その後 `collectIndentedRaw` が次行以降しか見ないので **値が
+      // 1 件も読まれずに黙って消える**。 書き間違いを黙って捨てないという `collectIndentedRaw`
+      // を自前で持った理由と矛盾する。
+      //
+      // 同じ行に何か書いてあれば形を問わず弾く = 1 行形は全て受けないという規則そのもの。
+      const inline = head.value?.trim();
+      if (inline) {
+        errors.push({
+          line: line.no,
+          message: "values は 1 行にまとめて書けない",
+          hint: '式に `,` が入るため。 次の行から字下げして `waiting: "{inflow} - {done}"` の形で並べる',
+        });
+        i += 1;
+        continue;
+      }
+      // `collectIndentedList` は `:` を含まない行を黙って捨てる。 捨てられると
+      // 書き間違えた行が「書かなかった」 と同じになり、 値が 1 つ消えたことに気付けない
+      const { items, next } = collectIndentedRaw(lines, i + 1, line.indent);
+      for (const it of items) {
+        const v = parseValueEntry(it.trimmed.replace(/^-\s*/, ""), it.no, errors);
+        if (v) values.push(v);
+      }
+      i = next;
+      continue;
+    }
     if (head.key === "animation") {
       // animation: は step を list で並べる
       const { items: stepBlocks, next } = collectAnimationSteps(lines, i + 1, line.indent);
@@ -316,12 +413,51 @@ export function parseTextDslV05(src: string): V05ParseResult {
       i = next;
       continue;
     }
+    if (head.key === "axes") {
+      // axes:\n  x: { left: "...", right: "..." }\n  y: { bottom: "...", top: "..." }
+      //
+      // **1 行にまとめて書く形は受けない** (Round 1 の指摘)。 受けないなら黙って捨てず、
+      // その場で伝える = 捨てると軸を書いたつもりの本文が既定のまま描かれる (`values:` と同じ)
+      if (head.value !== null && head.value.trim() !== "") {
+        errors.push({
+          line: line.no,
+          message: "axes は 1 行にまとめて書けない",
+          hint: '次の行から字下げして `x: { left: "...", right: "..." }` の形で並べる',
+        });
+        i += 1;
+        continue;
+      }
+      // **`collectIndentedList` を使わない** (Round 1 の指摘)。 あちらは `:` を含まない行を
+      // 黙って捨てるため、書き間違えた行が「書かなかった」 と同じになる
+      const { items, next } = collectIndentedRaw(lines, i + 1, line.indent);
+      axesLine = line.no;
+      const 組み立て: DslAxes = {};
+      for (const it of items) {
+        const m = it.trimmed.match(/^(x|y)\s*:\s*\{([^}]*)\}\s*$/);
+        if (!m) {
+          errors.push({
+            line: it.no,
+            message: `invalid axes entry: "${it.trimmed}"`,
+            hint: 'use `x: { left: "...", right: "..." }` or `y: { bottom: "...", top: "..." }`',
+          });
+          continue;
+        }
+        const opts = parseInlineMapping(m[2] ?? "");
+        if (m[1] === "x") 組み立て.x = { left: opts.left, right: opts.right };
+        else 組み立て.y = { bottom: opts.bottom, top: opts.top };
+      }
+      // 1 本も読めなかった形は「書かなかった」 と同じにする。 空の軸を渡すと、
+      // 書いていない側の名前が空文字で描かれる
+      axes = 組み立て.x !== undefined || 組み立て.y !== undefined ? 組み立て : undefined;
+      i = next;
+      continue;
+    }
     if (head.key === "lanes") {
       // lanes:\n  l1: { x: 0, width: 320, label: "..." }\n  l2: { ... }
       const { items, next } = collectIndentedList(lines, i + 1, line.indent);
       lanesMap = {};
       for (const it of items) {
-        const m = it.trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*\{([^}]*)\}\s*$/);
+        const m = it.trimmed.match(LANE_ID_ENTRY);
         if (m) {
           const id = m[1]!;
           const opts = parseInlineMapping(m[2]!);
@@ -350,7 +486,7 @@ export function parseTextDslV05(src: string): V05ParseResult {
       const { items, next } = collectIndentedList(lines, i + 1, line.indent);
       groupsMap = {};
       for (const it of items) {
-        const m = it.trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*\{([^}]*)\}\s*$/);
+        const m = it.trimmed.match(LANE_ID_ENTRY);
         if (m) {
           const id = m[1]!;
           const opts = parseInlineMapping(m[2]!);
@@ -389,9 +525,12 @@ export function parseTextDslV05(src: string): V05ParseResult {
     doc: {
       title: title!,
       type: type!,
+      ...(eyebrow !== null ? { eyebrow, eyebrowPos: { line: eyebrowLine } } : {}),
+      ...(axes !== undefined ? { axes, axesPos: { line: axesLine } } : {}),
       actors,
       flow,
       animate,
+      ...(values.length > 0 ? { values } : {}),
       viewport,
       lanes: lanesMap,
       groups: groupsMap,
@@ -803,6 +942,13 @@ function applyContinuationLines(actor: DslActor, rest: Line[], errors: DslError[
   let touchedState = false;
   /** 縦に並べて書かれた倍率。 同じ名前が 2 度出たら後の値で上書きする */
   const scaleWritten = new Map<string, string>();
+  /**
+   * 縦に並べて書かれた体験の道筋の欄 (#1251)。
+   *
+   * パーツでは状態の上書きとして意味を持つため、どちらに入れるかは block を読み終わってから
+   * 決める。 `kind:` の行が後ろに書かれることもあり、読んだ時点ではパーツか分からない。
+   */
+  const 図種ごとの欄 = new Map<string, string>();
   // パーツでなければどこにも入らない項目。 パーツかどうかは block を読み終わるまで決まらない
   const unknownKeys: Array<{ key: string; line: number }> = [];
 
@@ -916,6 +1062,15 @@ function applyContinuationLines(actor: DslActor, rest: Line[], errors: DslError[
         });
         break;
       }
+      case "touchpoint":
+      case "opportunity":
+      case "owner":
+      case "end":
+        // **どちらに入れるかは block を読み終わるまで決まらない** (#1251 Round 1 の指摘)。
+        // パーツかどうかは `kind:` の行で決まり、それが後ろに書かれることもある。
+        // 倍率 (`scaleWritten`) と読めない項目名 (`unknownKeys`) が同じ理由で後回しにしている
+        図種ごとの欄.set(key, stripQuotes(raw));
+        break;
       case "lane":
         out.lane = stripQuotes(raw);
         break;
@@ -937,6 +1092,18 @@ function applyContinuationLines(actor: DslActor, rest: Line[], errors: DslError[
     out.scale = s.scale;
     out.scaleKeys = [...new Set([...(actor.scaleKeys ?? []), ...s.keys])];
   }
+  // 体験の道筋の欄は、パーツなら状態の上書き、そうでなければ道筋の欄として入れる
+  for (const [key, v] of 図種ごとの欄) {
+    if (out.partId !== undefined) {
+      state[key] = coerceStateValue(v);
+      touchedState = true;
+      continue;
+    }
+    if (key === "touchpoint") out.touchpoint = v;
+    else if (key === "opportunity") out.opportunity = v;
+    else if (key === "owner") out.owner = v;
+    else out.end = v;
+  }
   // 状態も倍率も parts でだけ意味を持つ。 パーツなら知らせずに返す
   if (out.partId !== undefined) {
     if (touchedState) out.stateOverride = state;
@@ -969,6 +1136,10 @@ export const ACTOR_ITEM_KEYS: ReadonlySet<string> = new Set([
   "大きさ", "size",
   "倍率", "scale",
   "lane", "stack",
+  // 体験の道筋の欄 (#1251)
+  "touchpoint", "opportunity",
+  // 工程の並びの欄 (#1251)
+  "owner", "end",
 ]);
 
 /**
@@ -1092,6 +1263,9 @@ const ACTOR_RESERVED_FIELDS: ReadonlySet<string> = new Set([
   "initial",
   "final",
   "state",
+  // 体験の道筋の欄 (`touchpoint` / `opportunity`) はここに載せない (#1251 Round 1 の指摘)。
+  // 載せるとパーツで同じ名前の状態を書いた時に横取りされる = 既に動いている見本が静かに変わる。
+  // パーツでない箱でだけ道筋の欄として読む (`parseActor` / `applyContinuationLines` が分岐する)
   // canvas pivot 新 spec = 絶対座標 4 field (dragon canvas pivot spec §layout-role-conversion)
   "posX",
   "posY",
@@ -1220,9 +1394,13 @@ function reportScaleOnNonPart(
  * 並べた形) とは別に持つ = 中括弧の形は位置や大きさを未対応にしてあり、 同じ集合にすると
  * 「知らせない」 側がずれる。
  */
-const INLINE_ACTOR_KEYS: ReadonlySet<string> = new Set([
+export const INLINE_ACTOR_KEYS: ReadonlySet<string> = new Set([
   "kind", "subtitle", "eyebrow", "value", "rows", "lane", "stack",
   "initial", "final", "tone", "nodes",
+  // 体験の道筋の欄 (#1251)。 他の図種では組み立て側が知らせる
+  "touchpoint", "opportunity",
+  // 工程の並びの欄 (#1251)
+  "owner", "end",
   "posX", "posY", "posW", "posH",
   // 倍率は別経路 (`reportScaleOnNonPart`) が知らせる。 ここでも読める扱いにしないと
   // 同じ名前で 2 度知らせることになる
@@ -1233,6 +1411,25 @@ const INLINE_ACTOR_KEYS: ReadonlySet<string> = new Set([
 // している経路が予約語で残る (Round 1 review の指摘、 実測で確認)。 パーツ側は `isPart` の
 // 早期 return が先に効くのでここに載せる必要が無い
 
+/**
+ * 矢印の中括弧に書ける欄と、その読み方 (#1275)。
+ *
+ * **parser がこの表を回して読む**。 欄ごとに `opts.xxx` を並べる形だと、README や検査が
+ * 持つ一覧が実装と drift する = 欄を足しても誰も気付けない。 表を唯一の出どころにして、
+ * `FLOW_INLINE_KEYS` から一覧を導けるようにする。
+ */
+const FLOW_INLINE_READERS = {
+  sub: (v: string | undefined) => v,
+  guard: (v: string | undefined) => v,
+  cardinality: (v: string | undefined) => v,
+  labelOffsetX: (v: string | undefined) => numberOrUndef(v),
+  labelOffsetY: (v: string | undefined) => numberOrUndef(v),
+  overlay: (v: string | undefined) => boolOrUndef(v),
+} as const;
+
+/** 矢印の中括弧に書ける欄の名前。 README の一覧と突き合わせる (#1275) */
+export const FLOW_INLINE_KEYS = Object.keys(FLOW_INLINE_READERS) as readonly (keyof typeof FLOW_INLINE_READERS)[];
+
 /**
  * 中括弧に書かれた読めない項目名を知らせる (#1090)。
  *
@@ -1304,6 +1501,12 @@ function parseActor(line: Line, errors: DslError[]): DslActor | null {
       kindWritten: kindRaw !== "" && !isPart,
       subtitle: opts.subtitle,
       eyebrow: opts.eyebrow,
+      // パーツでは状態の上書きとして意味を持つため、道筋の欄として横取りしない (#1251)
+      touchpoint: isPart ? undefined : opts.touchpoint,
+      opportunity: isPart ? undefined : opts.opportunity,
+      // 見本では状態の上書きとして意味を持つため横取りしない (#1251)
+      owner: isPart ? undefined : opts.owner,
+      end: isPart ? undefined : opts.end,
       value: opts.value,
       rows: opts.rows
         ? opts.rows
@@ -1381,7 +1584,7 @@ function parseFlowStep(line: Line, no: number): DslStep | null {
   // 1. `Client -> API`                            ... label / option なし
   // 2. `Client -> API: "deposit"`                 ... label
   // 3. `Client -> API: "deposit" (success)`       ... label + tone tuple
-  // 4. `Client -> API: "deposit" { sub: "...", guard: "...", cardinality: "1:N", labelOffsetY: -8 }` ... inline option
+  // 4. `Client -> API: "deposit" { sub: "...", guard: "...", cardinality: "1:N", labelOffsetY: -8, overlay: true }` ... inline option
   // 5. `Client -> API: "deposit" (success) { guard: "..." }` ... 両方
   const raw = line.trimmed;
   const arrowIdx = raw.indexOf("->");
@@ -1391,22 +1594,21 @@ function parseFlowStep(line: Line, no: number): DslStep | null {
   let label = "";
   let tone: Tone | undefined;
   let style: EdgeStyle | undefined;
-  let sub: string | undefined;
-  let guard: string | undefined;
-  let cardinality: string | undefined;
-  let labelOffsetX: number | undefined;
-  let labelOffsetY: number | undefined;
+  // 欄は `FLOW_INLINE_READERS` の表から読む。 個別に並べると一覧が実装と drift する
+  const 中括弧: Partial<Record<keyof typeof FLOW_INLINE_READERS, unknown>> = {};
   // inline option (`{ ... }`) を末尾から抽出
   const mapMatch = rest.match(/\s*\{([^}]*)\}\s*$/);
   if (mapMatch) {
     const opts = parseInlineMapping(mapMatch[1]!);
-    sub = opts.sub;
-    guard = opts.guard;
-    cardinality = opts.cardinality;
-    labelOffsetX = numberOrUndef(opts.labelOffsetX);
-    labelOffsetY = numberOrUndef(opts.labelOffsetY);
+    for (const k of FLOW_INLINE_KEYS) 中括弧[k] = FLOW_INLINE_READERS[k](opts[k]);
     rest = rest.slice(0, mapMatch.index ?? 0).trim();
   }
+  const sub = 中括弧.sub as string | undefined;
+  const guard = 中括弧.guard as string | undefined;
+  const cardinality = 中括弧.cardinality as string | undefined;
+  const labelOffsetX = 中括弧.labelOffsetX as number | undefined;
+  const labelOffsetY = 中括弧.labelOffsetY as number | undefined;
+  const overlay = 中括弧.overlay as boolean | undefined;
   // 色と線種を末尾から取る。 括弧 (`(成功)`) と空白区切り (`成功`) の両方を受け付ける。
   //
   // 括弧は従来の書き方で、 catalog が使っている。 空白区切りは登場人物と揃えた形。
@@ -1453,15 +1655,17 @@ function parseFlowStep(line: Line, no: number): DslStep | null {
     cardinality,
     labelOffsetX,
     labelOffsetY,
+    overlay,
     pos: { line: line.no },
   };
 }
 
 function parseStateEntry(text: string, lineNo: number): DslState | null {
   // `client_bal: 100` / `status: "idle"`
-  const m = text.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
+  const m = text.match(/^([^:]+?)\s*:\s*(.+)$/);
   if (!m) return null;
-  const name = m[1] ?? "";
+  const name = (m[1] ?? "").trim();
+  if (!isValueName(name)) return null;
   const raw = (m[2] ?? "").trim();
   const stripped = stripQuotes(raw);
   const asNum = Number(stripped);
@@ -1469,6 +1673,77 @@ function parseStateEntry(text: string, lineNo: number): DslState | null {
   return { name, initial, pos: { line: lineNo } };
 }
 
+/**
+ * 字下げした行を 1 行も落とさずに集める。
+ *
+ * `collectIndentedList` は形が合わない行を黙って捨てるが、 `values` では捨てずに
+ * 読み手 (`parseValueEntry`) へ渡して書き間違いとして報告させる。
+ */
+function collectIndentedRaw(
+  lines: Line[],
+  start: number,
+  parentIndent: number,
+): { items: Line[]; next: number } {
+  const items: Line[] = [];
+  let i = start;
+  while (i < lines.length) {
+    const ln = lines[i];
+    if (!ln || !ln.trimmed || ln.trimmed.startsWith("#")) {
+      i += 1;
+      continue;
+    }
+    if (ln.indent <= parentIndent) break;
+    items.push(ln);
+    i += 1;
+  }
+  return { items, next: i };
+}
+
+/**
+ * `waiting: "{inflow} - {done}"` を 1 件の値として読む。
+ *
+ * 名前と式の判定は `value-syntax.ts` が持つ (#1181)。 JSON 経路も同じ判定を使うため、
+ * ここでは行番号を付けて報告する形にだけ責任を持つ。
+ */
+function parseValueEntry(text: string, lineNo: number, errors: DslError[]): DslValue | null {
+  const m = text.match(/^([^:]+?)\s*:\s*(.+)$/);
+  if (!m) {
+    errors.push({
+      line: lineNo,
+      message: `invalid value entry: "${text}"`,
+      hint: '`waiting: "{inflow} - {done}"` の形で書く',
+    });
+    return null;
+  }
+  const name = (m[1] ?? "").trim();
+  if (!isValueName(name)) {
+    errors.push({ line: lineNo, ...valueNameIssue(name) });
+    return null;
+  }
+  const rest = (m[2] ?? "").trim();
+  // きっかけ形 (`{ trigger: ..., to: ..., dur: ... }`) を先に見る。 式として読むと中括弧の中身が
+  // 値の名前として検査され、 「trigger は名前に使えない」 のような直し方の伝わらない誤りになる
+  if (isTriggerBody(rest)) {
+    const { spec, issues } = parseValueTriggerBody(rest.slice(1, -1), name);
+    if (spec === null) {
+      for (const issue of issues) errors.push({ line: lineNo, ...issue });
+      return null;
+    }
+    return { name, trigger: spec.trigger, to: spec.to, durationMs: spec.durationMs, pos: { line: lineNo } };
+  }
+  const expression = stripQuotes(rest);
+  if (expression === "") {
+    errors.push({ line: lineNo, message: `empty expression for "${name}"`, hint: '`"{a} + {b}"` のように式を書く' });
+    return null;
+  }
+  const issues = checkValueExpression(expression, name);
+  if (issues.length > 0) {
+    for (const issue of issues) errors.push({ line: lineNo, ...issue });
+    return null;
+  }
+  return { name, expression, pos: { line: lineNo } };
+}
+
 function splitTopLevelCommas(s: string): string[] {
   // brace 内を考慮 ... 今回は単純 split (動作する範囲)
   return s.split(",").map((x) => x.trim()).filter(Boolean);
@@ -1605,12 +1880,26 @@ function parseFocusList(s: string): string[] {
   // quote 内の space / comma / arrow は保護し、 quote 外の comma でのみ split する。
   let body = s.trim();
   if (body.startsWith("[") && body.endsWith("]")) body = body.slice(1, -1);
-  const parts: string[] = [];
+  // **引用部分を非引用部分と分けて覚えておく** (#1192)。 区間全体に quoted flag を
+  // 付けるだけだと `Client "Aave v3"` まで 1 item になり、従来の空白区切りと混在できない。
+  type FocusFragment = { text: string; quoted: boolean };
+  const groups: FocusFragment[][] = [];
+  let group: FocusFragment[] = [];
   let buf = "";
   let quote: string | null = null;
+  const pushFragment = (quoted: boolean): void => {
+    if (buf.trim()) group.push({ text: buf, quoted });
+    buf = "";
+  };
+  const pushGroup = (): void => {
+    pushFragment(false);
+    if (group.length > 0) groups.push(group);
+    group = [];
+  };
   for (const ch of body) {
     if (quote) {
       if (ch === quote) {
+        pushFragment(true);
         quote = null;
         continue;
       }
@@ -1618,36 +1907,43 @@ function parseFocusList(s: string): string[] {
       continue;
     }
     if (ch === "\"" || ch === "'") {
-      quote = ch;
-      continue;
+      // item の途中にある引用符は名前の一部。 空白または区切りの直後だけ囲みを開始する。
+      if (!buf || /\s$/.test(buf)) {
+        pushFragment(false);
+        quote = ch;
+        continue;
+      }
     }
     if (ch === ",") {
-      const t = buf.trim();
-      if (t) parts.push(t);
-      buf = "";
+      pushGroup();
       continue;
     }
     buf += ch;
   }
-  const tail = buf.trim();
-  if (tail) parts.push(tail);
-  // "User -> API" のような quote 済 item は「1 item」 として parts に入る。
+  pushFragment(quote !== null);
+  if (group.length > 0) groups.push(group);
+  // "User -> API" のような quote 済 item は「1 item」 として groups に入る。
   // quote 外 item は依然として space split (旧挙動、 「Client API」 が 2 item として解釈される互換維持)。
   const out: string[] = [];
-  for (const p of parts) {
-    if (/[-→][>]?/.test(p) && /\s/.test(p)) {
-      // arrow を含む item は「A -> B」 パターン、 分割せず 1 item として保持
-      out.push(p);
+  for (const fragments of groups) {
+    const whole = fragments.map(({ text }) => text).join("").trim();
+    if (fragments.every(({ quoted }) => !quoted) && /[-→][>]?/.test(whole) && /\s/.test(whole)) {
+      // arrow を含む非引用区間は「A -> B」パターン。 空白で分割しない。
+      out.push(whole);
       continue;
     }
-    if (/\s/.test(p)) {
-      // space 含み + arrow なし = 旧挙動の「Client API」 → 2 item
-      for (const x of p.split(/\s+/)) {
-        if (x) out.push(x);
+    for (const { text, quoted } of fragments) {
+      const p = text.trim();
+      if (!p) continue;
+      // 引用符で囲んだ item は空白があっても切らず、非引用部分だけを従来どおり空白で切る。
+      if (quoted) {
+        out.push(p);
+      } else {
+        for (const x of p.split(/\s+/)) {
+          if (x) out.push(x);
+        }
       }
-      continue;
     }
-    out.push(p);
   }
   return out;
 }
@@ -1655,10 +1951,12 @@ function parseFocusList(s: string): string[] {
 function parseTweenLine(s: string, lineNo: number): DslTween | null {
   // `client_bal 100 -> 90` / `client_bal: 100 -> 90`
   const cleaned = s.replace(/^-\s*/, "").trim();
-  const m = cleaned.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*[:\s]\s*(-?\d+(?:\.\d+)?)\s*->\s*(-?\d+(?:\.\d+)?)$/);
+  const m = cleaned.match(/^([^:\s]+)\s*[:\s]\s*(-?\d+(?:\.\d+)?)\s*->\s*(-?\d+(?:\.\d+)?)$/);
   if (!m) return null;
+  const state = m[1] ?? "";
+  if (!isValueName(state)) return null;
   return {
-    state: m[1] ?? "",
+    state,
     from: parseFloat(m[2] ?? "0"),
     to: parseFloat(m[3] ?? "0"),
     pos: { line: lineNo },
@@ -1668,11 +1966,13 @@ function parseTweenLine(s: string, lineNo: number): DslTween | null {
 function parseSetLine(s: string, lineNo: number): DslSet | null {
   // `status: "loading"` / `status loading`
   const cleaned = s.replace(/^-\s*/, "").trim();
-  const m = cleaned.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*[:\s]\s*(.+)$/);
+  const m = cleaned.match(/^([^:\s]+)\s*[:\s]\s*(.+)$/);
   if (!m) return null;
+  const state = m[1] ?? "";
+  if (!isValueName(state)) return null;
   const raw = (m[2] ?? "").trim();
   const stripped = stripQuotes(raw);
   const asNum = Number(stripped);
   const value: number | string = Number.isFinite(asNum) && stripped !== "" && !isNaN(asNum) ? asNum : stripped;
-  return { state: m[1] ?? "", value, pos: { line: lineNo } };
+  return { state, value, pos: { line: lineNo } };
 }