@cardenelabs/dragon 0.34.0 → 0.35.0

package/src/notation-lint.ts

@@ -1,342 +0,0 @@
-/**
- * 記法の検査 (図を書く人向けの修正システム)。
- *
- * cdl / dragon の記法で書いた図 (`CdlDiagram`) を決まった規則で検査し、直し方を修正案
- * (`suggestion`) として返す純粋関数。 言語モデルは使わない。
- *
- * 検知システム (`check:cdl` / `check:dragon` / `check:kind`) は開発者向けで実装の不具合を
- * 見つける。 こちらは図を書く人向けで、読む人へ伝わらない書き方 (図の説明に入り込んだ実装の
- * 書き方、無い部品を指す参照、値や項目が空の図表など) を見つける。
- *
- * 使い方:
- *   import { lintDiagram, autoFix } from "@cardenelabs/dragon";
- *   const report = lintDiagram(diagram);
- *   // report.issues = LintIssue[]
- *   // report.autoFixableCount = 自動修正で実際に解消できる指摘の数
- *   const patched = autoFix(diagram); // 自動修正を当てた新しい図 (元の図は変えない)
- *
- * 道具:
- *   node packages/dragon/scripts/dragon-lint.mjs 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;
-  /**
-   * 書き手向けの指摘の文。 書き手が打ち込む識別子と書き手の値は `` ` `` で囲み、 残りは日本語で書く
-   * (画面側の `lint-message-words.test.ts` が全規則の文を判定に通す)
-   */
-  message: string;
-  /** 修正案。 自動修正できる指摘は自動修正が書く値そのもの、 できない指摘は直し方の文 */
-  suggestion?: string;
-  /** autoFix() が本 issue を自動解消できるか */
-  autoFixable: boolean;
-};
-
-export type LintReport = {
-  diagramId: string;
-  issues: LintIssue[];
-  /** autoFix() が実際に解消できる issue の数 */
-  autoFixableCount: number;
-};
-
-/**
- * 図の説明に入り込んだ実装の書き方と、 読む人に何が伝わらないか。
- *
- * 文は理由だけを持ち、 直し方の例を書かない。 直し方は修正案 (`suggestion`) が自動修正の
- * 出力から作る。 例を字で書くと、 自動修正の出力を変えた日に例だけが古い文型で残る
- * (実測 = #1934 で出力を変えた後も `「〜 を示す図」 のように` が残っていた、 #1940)。
- */
-const REDUNDANT_TOPIC_PATTERNS: Array<{ pattern: RegExp; hint: string }> = [
-  { pattern: /\bpreset\s*\(/i, hint: "`preset (…)` は作り手の書き方で、 読む人には何を示す図かが伝わらない" },
-  { pattern: /render\s*未実装/, hint: "`render 未実装` は作り手向けの控えで、 カタログに出す説明には要らない" },
-  {
-    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 先頭の型の名前 =
-  /^\s*(line chart|pie chart|bar chart|chart|flow|swimlane|sequence|topology|er|stateMachine2?|infrastructure|classDiagram|tree|userJourney|mindMap|funnel|quadrant|gantt|flowchart|network)\b/i;
-
-/**
- * 図の説明から実装の語を落とす。
- *
- * **落とすだけで、文は書かない** (#2687)。
- *
- * 以前は先頭が型の名前なら `${shows}を示す${name}` に丸ごと書き換えていた。
- * 出てくるのは必ず図種の定義文 (「全体に対する内訳の割合を示す円グラフ」) で、
- * その図が何を示しているかは 1 文字も入らない。
- * cdl 0.96.0 で説明が図の題として画面に出るようになり、見本帳の 8 枚がその形で出ていた。
- *
- * 道具は図の中身を知らないので、名前を作れない。 落とした結果が説明として成り立たないなら
- * **元の字をそのまま返す** = 呼出側が「自動修正で消えない」 と判定し、書き手に名前を求める。
- * 置き換えの語 (かつての「図の説明」) を返すと、道具が書いた仮の題が画面に出る。
- */
-function applyTopicAutoFix(topic: string): string {
-  let out = topic;
-  out = out.replace(/\s*\([^)]*(preset|render|SVG|polygon|polyline|arc|rect|path)[^)]*\)/gi, "");
-  out = out.replace(先頭の型の名前, "");
-  out = out.replace(/\b(preset|render)\b/gi, "");
-  // 落とした跡に残る区切りを畳む
-  out = out.replace(/^[\s\-—:：・]+/, "").replace(/\s+/g, " ").trim();
-  // 括弧の中しか残らなかった形 (`(詳細)`) は説明として成り立たない。
-  // 字数だけで見ると 4 字あるので通ってしまう
-  const 括弧の外 = out.replace(/[（(][^）)]*[）)]/g, "").trim();
-  if (out.length < 3 || 括弧の外.length < 3) return topic;
-  return out;
-}
-
-/**
- * 図の説明に実装の書き方が入っていないかを見る。
- *
- * **自動修正で消えるかは、 直した後の説明にもう 1 度当てて決める** (#1940)。 自動修正が消すのは
- * 先頭の型の名前と、 括弧の中の実装の言葉だけで、 括弧の外の `SVG polyline を使う` は字が変わらない。
- * 当てずに「直せる」 と返すと、 道具が直せる数に入れ、 直したはずの指摘が次の検査でまた出る。
- *
- * 修正案は、 直せる時は自動修正が書く値そのもの (`LintIssue.suggestion` の約束)、 直せない時は
- * 直し方の文にする。 文の例は書き換え先の表から作り、 字で書かない。
- */
-function ruleTopicRedundancy(d: CdlDiagram): LintIssue[] {
-  const 当たる = REDUNDANT_TOPIC_PATTERNS.filter(({ pattern }) => pattern.test(d.topic));
-  if (当たる.length === 0) return [];
-  const 直した後 = applyTopicAutoFix(d.topic);
-  const 直せる =
-    直した後 !== d.topic &&
-    !REDUNDANT_TOPIC_PATTERNS.some(({ pattern }) => pattern.test(直した後));
-  // 例は見本帳の実物から採る (#2687)。 型の表から作ると図種の定義文になり、
-  // 案内どおりに書いた説明がそのまま図の題として画面に出る
-  const 手で直す = "その図が何を示しているかを名前で書く (「経路別の流入」 のように)";
-  return 当たる.map(({ hint }) => ({
-    rule: "topic-redundant-implementation-detail",
-    severity: "warn",
-    target: d.id,
-    message: `図の説明 \`${d.topic}\` に実装の書き方が入っている。 ${hint}`,
-    suggestion: 直せる ? 直した後 : 手で直す,
-    autoFixable: 直せる,
-  }));
-}
-
-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: `図表 \`${n.id}\` に値 (\`datum\`) が 1 件も無く、 図表が描かれない`,
-          suggestion: `\`.datum({ id, label, value })\` で値を 1 件以上足す`,
-          autoFixable: false,
-        });
-      }
-      if (data.length === 1) {
-        out.push({
-          rule: "chart-single-datum",
-          severity: "info",
-          target: n.id,
-          message: `図表 \`${n.id}\` の値 (\`datum\`) が 1 件だけで、 比べることも移り変わりを追うこともできない`,
-          suggestion: `値を 2 件以上にする (折れ線グラフは 3 件以上で傾きが読める)`,
-          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) {
-        const dependencies = Array.isArray(t.dependsOn) ? t.dependsOn : t.dependsOn ? [t.dependsOn] : [];
-        for (const dependency of dependencies) {
-          if (!ids.has(dependency)) {
-            out.push({
-              rule: "gantt-unknown-depends-on",
-              severity: "warn",
-              target: t.id,
-              message: `作業 \`${t.id}\` の \`dependsOn\` が、 無い作業 \`${dependency}\` を指している`,
-              suggestion: `\`dependsOn\` を既にある作業の \`id\` に直すか、 \`dependsOn\` を外す`,
-              autoFixable: false,
-            });
-          }
-        }
-      }
-    }
-  }
-  return out;
-}
-
-/**
- * 枝の親が実在するかを見る。
- *
- * **記法からも届く** (`#1177`)。 一時期は組立て API (`mindMap()` builder) で組んだ図にしか
- * 当たらなかった = 記法の `type: mind` が `card` を 3 列に並べる別実装で、 `mind-map` 種別を
- * 作っていなかったため (`#1170` で `type: radial` が消えて唯一の作り手が無くなった)。
- * `#1177` で `compileMind` を `mind-map` 種別に寄せたので、 前提が揃うようになった。
- *
- * ただし **記法から違反が出ることは無い**。 記法の `actors` は「1 つ目が中心、 残りが枝」 の
- * 並びで親を書く場所が無く、 全ての枝が中心の直下 (必ず実在する) になるため。 違反が出るのは
- * 組立て API で親を書き間違えた図になる。
- */
-function ruleMindMapParentReference(d: CdlDiagram): LintIssue[] {
-  const out: LintIssue[] = [];
-  for (const n of d.nodes) {
-    if (n.kind === "mind-map" && 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: `枝 \`${b.id}\` の \`parent\` が、 無い枝 \`${b.parent}\` を指している`,
-            suggestion: `\`parent\` を中心 (\`${n.mindData.rootId}\`) か、 既にある枝の \`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: `階層図の項目 \`${t.id}\` の \`parent\` が、 無い項目 \`${t.parent}\` を指している`,
-            suggestion: `\`parent\` を既にある項目の \`id\` に直すか、 \`parent\` を外して一番上の項目にする`,
-            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: `マトリクス図 \`${n.id}\` に項目 (\`item\`) が 1 件も無く、 軸だけが描かれる`,
-          suggestion: `\`.item({ id, title, quadrant })\` で項目を 1 件以上足す (\`quadrant\` は \`topLeft\` などの 4 区画から選ぶ)`,
-          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: `マトリクス図 \`${n.id}\` の項目がすべて 1 つの区画に集まり、 4 つに分けた意味が薄い`,
-          suggestion: `項目を 2 つ以上の区画に分ける。 強みと弱みを並べる分析 (\`SWOT\`) や優先度を決める図は、 4 つの区画に散らして使う`,
-          autoFixable: false,
-        });
-      }
-    }
-  }
-  return out;
-}
-
-/**
- * 段階の人数が減っていくことを見る。
- *
- * 人数の欄は `{名前}` を書ける (状態から取る形、 cdl の `render/payload-binding.ts` が解く)。
- * その場合ここでは値が決まらないので、**数どうしの組だけを比べる** (#1194)。
- *
- * 素通しで比べると文字列の大小比較になり、`{trial}` が `{signup}` より大きいという理由で
- * 発火する。 実際にカタログの funnel を状態から取る形にした時、その偽発火が出た。
- */
-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++) {
-        const 今 = stages[i]!.count;
-        const 前 = stages[i - 1]!.count;
-        if (typeof 今 !== "number" || typeof 前 !== "number") continue;
-        if (今 > 前) {
-          out.push({
-            rule: "funnel-increasing-count",
-            severity: "warn",
-            target: stages[i]!.id,
-            message: `段階 \`${stages[i]!.id}\` の数 (${今}) が前の段階 (${前}) より多い。 ファネル図は段階が進むほど数が減る`,
-            suggestion: `段階の順番を確かめる。 数が増える流れを示すなら、 折れ線グラフ (\`chart-line\`) などの別の図にする`,
-            autoFixable: false,
-          });
-        }
-      }
-    }
-  }
-  return out;
-}
-
-// dev-only import bridging (unused var lint prevention)
-export type { CdlDiagram, CdlNode };

package/src/relative-pos.ts

@@ -1,251 +0,0 @@
-/**
- * 位置を他の要素からの相対で書くための解決。
- *
- * `位置: Web の右 200` のように、 座標の代わりに「誰の」「どちら側に」「どれだけ離して」 を書く。
- * 書く人も LLM も座標を知らないので、 数値を当てさせない形を用意する。
- *
- * 解決結果は絶対座標 (`posX` / `posY`) で、 座標を直接書いた時と同じ経路を通る。
- * 書き方が増えるだけで、 効き方は変わらない。
- *
- * 座標を決める場所が組み立て側 (`compile.ts`) と画面側 (playground の `overlay-dsl.ts`) の
- * 2 つあるため、 解決の規則は本 file に 1 つだけ置いて両方から呼ぶ。 片方だけ直すと画面が
- * 直らない事故を、 規則を共有することで構造的に防ぐ。
- */
-
-/**
- * 基準からどちら側に置くか。
- *
- * 語の一覧は下の `RELATIVE_DIRECTIONS` が持つ。 型を並べ直さず、一覧から導く。
- */
-export type RelativeDirection = (typeof RELATIVE_DIRECTIONS)[number];
-
-/**
- * 向きとして受ける語の一覧。
- *
- * 読み取りの入口が 2 つある (本文の `位置: Web の右 200` と JSON の `posRel.dir`) ため、
- * 一覧を 1 箇所に置いて両方から引く。 2 度書くと、向きを足した時に片方だけが取り残される。
- */
-export const RELATIVE_DIRECTIONS = ["right", "left", "above", "below"] as const;
-
-/** 相対で書かれた位置の指定。 */
-export type RelativePos = {
-  /** 基準にする相手の名前。 `actors:` に書かれた名前をそのまま持つ。 */
-  anchor: string;
-  dir: RelativeDirection;
-  /** 相手との間隔。 書かなかった時は `RELATIVE_GAP_DEFAULT`。 */
-  gap?: number;
-};
-
-/** 位置を決めるのに必要な、 基準の中心と大きさ。 */
-export type AnchorBox = { cx: number; cy: number; w: number; h: number };
-
-/**
- * 間隔を書かなかった時の既定値。
- *
- * 8 図種 × 4 向きで間隔を変えながら、 cdl が出す近すぎ系の指摘の数を数えて決めた。
- * 100 で 17 件、 130 で 10 件、 140 で 4 件と減り、 160 で 2 件に落ちて以降は変わらない。
- * 残る 2 件は間隔と無関係な指摘なので、 減らなくなる 160 を既定にする。
- *
- * 自動配置が空ける隙間も実測では縦 100 / 横 256-406 で、 160 はその間に収まる。
- * 隣に置いたと読める近さと、 詰まって見えない広さの両方を満たす。
- */
-export const RELATIVE_GAP_DEFAULT = 160;
-
-/**
- * 書かれた向きの語。 日本語と英語の両方を受け付ける。
- *
- * 項目名が日本語でも英語でもよい (`種類` / `kind`) のと揃える。
- */
-const DIRECTION_WORDS: Readonly<Record<string, RelativeDirection>> = {
-  右: "right",
-  左: "left",
-  上: "above",
-  下: "below",
-  right: "right",
-  left: "left",
-  above: "above",
-  below: "below",
-};
-
-/**
- * 間隔として受け付ける数の形。
- *
- * 負の数は含めない (向きが裏返るため)。 小数と指数表記は受け付ける。 整数だけに絞ると、
- * 有効な数を書いたのに「書き方が読めません」 と返す (実測 = `1e2` / `.5` が弾かれた)。
- */
-const GAP_NUM = String.raw`(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?`;
-
-/**
- * 日本語の形。 `Web の右` / `Web の右 200` / `Web の右200`。
- *
- * 相手の名前は控えめ (`.+?`) に取る。 名前自体が `の右` で終わる場合 (`Aの右 の左`) でも、
- * 後戻りして末尾の向きを先に確定するため取り違えない。
- */
-const RE_JA = new RegExp(String.raw`^(.+?)\s*の\s*(右|左|上|下)(?:\s*(${GAP_NUM}))?$`);
-
-/** 英語の形。 `Web right` / `Web right 200`。 向きの前後は空白で区切る。 */
-const RE_EN = new RegExp(String.raw`^(.+?)\s+(right|left|above|below)(?:\s+(${GAP_NUM}))?$`, "i");
-
-/**
- * `位置:` に書かれた値を相対指定として読む。 相対の形でなければ null。
- *
- * 座標の形 (`300,200`) は呼ぶ側が先に判定する。 ここは相対だけを見る。
- */
-export function parseRelativePos(raw: string): RelativePos | null {
-  const s = raw.trim();
-  if (s === "") return null;
-  const m = s.match(RE_JA) ?? s.match(RE_EN);
-  if (!m) return null;
-  const anchor = m[1]!.trim();
-  if (anchor === "") return null;
-  const dir = DIRECTION_WORDS[m[2]!.toLowerCase()];
-  if (dir === undefined) return null;
-  const gapRaw = m[3];
-  if (gapRaw === undefined) return { anchor, dir };
-  const gap = Number(gapRaw);
-  // 数として読めない間隔は書かなかった扱いにする。 既定の間隔で置く方が、
-  // 図から消えるより書いた人が気付きやすい。
-  return Number.isFinite(gap) ? { anchor, dir, gap } : { anchor, dir };
-}
-
-/**
- * 相対指定を絶対座標に直す。
- *
- * `posX` / `posY` は箱の中心。 間隔は箱の縁と縁の間の距離として扱う。 中心間の距離にすると、
- * 大きさの違う箱を並べた時に見た目の隙間が揃わない。
- */
-export function resolveRelativePos(
-  rel: RelativePos,
-  anchor: AnchorBox,
-  target: { w: number; h: number },
-): { posX: number; posY: number } {
-  // 負の間隔は向きを裏返す。 `Web の右 -1000` が Web の左に置かれ、 確かめる側も同じ値で
-  // 期待を作るので矛盾に気付けない (実測 = 右と書いて左に出た)。 間隔は 0 以上として扱う。
-  // 記法から来る値は parser が弾くが、 本関数は公開しているので入口で閉じる
-  const raw = rel.gap ?? RELATIVE_GAP_DEFAULT;
-  const gap = Number.isFinite(raw) && raw >= 0 ? raw : RELATIVE_GAP_DEFAULT;
-  const dx = anchor.w / 2 + gap + target.w / 2;
-  const dy = anchor.h / 2 + gap + target.h / 2;
-  switch (rel.dir) {
-    case "right":
-      return { posX: anchor.cx + dx, posY: anchor.cy };
-    case "left":
-      return { posX: anchor.cx - dx, posY: anchor.cy };
-    case "below":
-      return { posX: anchor.cx, posY: anchor.cy + dy };
-    case "above":
-      return { posX: anchor.cx, posY: anchor.cy - dy };
-  }
-}
-
-/**
- * 相対指定を解く順番を決める。
- *
- * 基準にした相手がまた相対で書かれていることがある (`B は A の右`、 `C は B の右`)。
- * 先に相手が決まっていないと座標を出せないので、 依存の浅い順に並べ替える。
- *
- * 輪になっている分 (`A は B の右`、 `B は A の右`) は解けないため、 順番からは外して
- * 名前だけを返す。 呼ぶ側が誤りとして扱う。
- */
-export function orderByDependency(
-  items: ReadonlyArray<{ name: string; rel?: RelativePos }>,
-): { order: string[]; cyclic: string[] } {
-  const relOf = new Map<string, RelativePos>();
-  const known = new Set<string>();
-  for (const it of items) {
-    known.add(it.name);
-    if (it.rel) relOf.set(it.name, it.rel);
-  }
-  const order: string[] = [];
-  const done = new Set<string>();
-  const cyclic = new Set<string>();
-
-  // 再帰にすると基準の連鎖の長さだけ stack を積む。 連鎖の長さは書く人が決めるので
-  // 上限を置けない。 明示的な配列で辿る。
-  for (const it of items) {
-    if (done.has(it.name) || cyclic.has(it.name)) continue;
-    // path は [自分, 基準, 基準の基準, ...] の順に伸びる
-    const path: string[] = [];
-    const onPath = new Set<string>();
-    let cur: string | undefined = it.name;
-    while (cur !== undefined) {
-      if (done.has(cur) || cyclic.has(cur)) break;
-      if (onPath.has(cur)) {
-        // 輪を見つけた。 輪に含まれる分だけを外す。 輪に入る手前の分は解けるので残す
-        for (const n of path.slice(path.indexOf(cur))) cyclic.add(n);
-        break;
-      }
-      path.push(cur);
-      onPath.add(cur);
-      const rel = relOf.get(cur);
-      // 相対で書かれていない、 または相手が居ない = ここで辿り終わり
-      if (rel === undefined || !known.has(rel.anchor)) break;
-      cur = rel.anchor;
-    }
-    // 奥 (基準側) から順に並べる。 基準が先に決まっていないと座標を出せない
-    for (let i = path.length - 1; i >= 0; i -= 1) {
-      const n = path[i]!;
-      if (cyclic.has(n) || done.has(n)) continue;
-      done.add(n);
-      order.push(n);
-    }
-  }
-  return { order, cyclic: [...cyclic] };
-}
-
-/** 解けない書き方の種類。 誤りの文は入口ごとに作るので、ここでは種類だけを返す */
-export type RelativeProblemKind = "self" | "missing-anchor" | "cyclic";
-
-/** 解けない書き方 1 件。 `anchor` は相手が居ない時だけ持つ */
-export type RelativeProblem = {
-  name: string;
-  kind: RelativeProblemKind;
-  anchor?: string;
-};
-
-/**
- * 解けない相対の指定を挙げる (#2039)。
- *
- * 解けない書き方は 3 通りある。 相手が居ない / 自分を基準にした / 基準が輪になっている。
- * どれも「書いたのに図が変わらない」 形で表に出るため、図を出す前に知らせる。
- *
- * **判定は本 file に 1 つだけ置く**。 読み取りの入口が 2 つある (本文と JSON) ため、
- * 片方だけに判定を持つと、同じ書き方が入口によって通ったり通らなかったりする。
- * 実際 JSON 側には判定が無く、相対で置く欄そのものが無かった。
- *
- * 誤りの文は返さない。 本文側は行番号を、JSON 側は欄の場所を添えるため、文の組み立ては
- * 入口に任せる。 ここが返すのは「誰の」「どの種類の」 解けなさか だけ。
- *
- * 呼ぶ側は、挙がった名前から相対の指定を外す。 残したままだと、誤りを無視して読み込んだ
- * 経路で解決できない指定が組み立てまで届く。
- */
-export function findRelativeProblems(
-  items: ReadonlyArray<{ name: string; rel?: RelativePos }>,
-): RelativeProblem[] {
-  const named = new Set(items.map((i) => i.name));
-  const broken = new Set<string>();
-  const out: RelativeProblem[] = [];
-
-  for (const it of items) {
-    const rel = it.rel;
-    if (!rel) continue;
-    if (rel.anchor === it.name) {
-      out.push({ name: it.name, kind: "self" });
-      broken.add(it.name);
-      continue;
-    }
-    if (!named.has(rel.anchor)) {
-      out.push({ name: it.name, kind: "missing-anchor", anchor: rel.anchor });
-      broken.add(it.name);
-    }
-  }
-
-  // 輪は、既に解けないと判った分を外してから探す。 外さないと「相手が居ない」 1 件が
-  // 「輪になっている」 としても挙がり、同じ 1 つの誤りが 2 通りの直し方で出る
-  const { cyclic } = orderByDependency(
-    items.map((i) => ({ name: i.name, rel: broken.has(i.name) ? undefined : i.rel })),
-  );
-  for (const name of cyclic) out.push({ name, kind: "cyclic" });
-
-  return out;
-}