chaffjs 0.28.0 → 0.30.0

package/src/structure/connection-times.ts

@@ -0,0 +1,226 @@
+import type { StructureIssue } from "./issues.ts";
+import { lineNumberAt, linesOf, type Line } from "./lines.ts";
+import { runsOf } from "./runs.ts";
+import type { Stop } from "./time-order.ts";
+import {
+  crossesZones,
+  dayShiftOf,
+  markBefore,
+  markSoonAfter,
+  wordOffsets,
+  zonesIn,
+  type DateSpan,
+  type Mark,
+  type TimeSpan,
+  type TimeWords,
+} from "./time-marks.ts";
+
+/**
+ * 乗り継ぎの間が、文書に書いた移動の時間より短い所。移動の時間は、移動の語（移動、徒歩、地下鉄、by Metro、coach。語彙表
+ * travel-time-word）と同じ文に書いた長さ（約10分、about 40 minutes）だけを使う。実際にかかる時間は推し量らない。
+ * 移動の始まりと終わりの時刻は二通りに読む。
+ * - 移動そのものを書いた予定（「10:00 京都駅から貸切バスで清水寺へ（約30分）」）は、その時刻に発ち、同じ日の次の予定までに着く。
+ * - 予定に添えた移動の時間（「09:55 博多駅で合流（福岡空港から地下鉄で約10分）」）や、時刻の無い移動の文に続けて書いた時刻は、
+ *   すぐ前の着の時刻（「福岡 09:50着」、表の到着の列）から移動して、その時刻に間に合う。
+ * 日付が違う、翌日の印がある、時刻が戻る（夜をまたぐ）、時間帯の印が違う所は比べない。
+ */
+
+/** 移動の時間として読む長さ。minutes は分。 */
+export type TravelLength = { readonly start: number; readonly end: number; readonly minutes: number };
+
+/** cues は移動を言う語、bounds は長さを上限として言う語（以内、within）。上限の長さは、それより早く着けるので使わない。 */
+export type TravelWords = { readonly cues: readonly Mark[]; readonly bounds: readonly Mark[] };
+
+export type ConnectionInputs = {
+  readonly source: string;
+  readonly times: readonly TimeSpan[];
+  readonly dates: readonly DateSpan[];
+  readonly words: TimeWords;
+  readonly travel: TravelWords;
+  readonly lengths: readonly TravelLength[];
+  readonly arrivals: ReadonlySet<number>;
+  readonly days: readonly (readonly Stop[])[];
+};
+
+const SECONDS_PER_MINUTE = 60;
+
+/** 文の切れ目。leg-times.ts と同じ。 */
+const BREAK = /[。．;；!?！？]|\.\s/gu;
+/** 括弧書き。中に括弧を入れ子にしたものは、内側から一つずつ外す。 */
+const BRACKETED = /[(（][^()（）]*[)）]/gu;
+/** 「within 10 minutes」の within と長さの間に挟んでよい字の数。 */
+const BOUND_GAP = 1;
+
+/** 発ってから着くまでの間が、書いた移動の時間より短いか。間が負なら（時刻が戻る）、夜をまたいだのか書き間違いか決められないので言わない。 */
+export const isTooShort = (gapSeconds: number, travelMinutes: number): boolean => gapSeconds >= 0 && gapSeconds < travelMinutes * SECONDS_PER_MINUTE;
+
+/** 二つの時刻に書いた日付が比べられるか。両方に無いか、同じ書き方で同じ日付なら同じ日。 */
+export const isSameDate = (left: string | undefined, right: string | undefined): boolean => left === right;
+
+/** 時間帯の印を見て、二つの行の時刻をそのまま比べられるか。どちらかが時間帯をまたぐか、印が違えば比べない。 */
+export const isSameZone = (left: string, right: string, words: TimeWords): boolean => {
+  const [leftZones, rightZones] = [zonesIn(left, words), zonesIn(right, words)];
+  if (crossesZones(leftZones) || crossesZones(rightZones)) return false;
+  return (leftZones[0]?.text ?? "") === (rightZones[0]?.text ?? "");
+};
+
+/** 括弧書きを外した残り。 */
+export const outsideBrackets = (text: string): string => {
+  const stripped = text.replace(BRACKETED, " ");
+  return stripped === text ? text : outsideBrackets(stripped);
+};
+
+/** text に移動の語が一語として書かれているか。大文字と小文字は区別しない。 */
+export const mentionsTravel = (text: string, cues: readonly Mark[]): boolean => {
+  const lower = text.toLowerCase();
+  return cues.some((cue) => wordOffsets(lower, cue.pattern.toLowerCase()).length > 0);
+};
+
+/** 行の中で、at から to までを含む文の範囲（行の頭からの位置）。 */
+export const sentenceAround = (text: string, at: number, to: number): { start: number; end: number } => {
+  const breaks = [...text.matchAll(BREAK)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+  const start = breaks.filter((cut) => cut.end <= at).at(-1)?.end ?? 0;
+  const end = breaks.find((cut) => cut.start >= to)?.start ?? text.length;
+  return { start, end };
+};
+
+const lineAt = (lines: readonly Line[], offset: number): Line | undefined => {
+  const number = lineNumberAt(lines, offset);
+  return number === undefined ? undefined : lines[number - 1];
+};
+
+/** 長さが上限として書かれている（10分以内、within 10 minutes）か。 */
+const isBound = (inputs: ConnectionInputs, line: Line, length: TravelLength): boolean => {
+  const head = inputs.source.slice(line.start, length.start).toLowerCase();
+  return markSoonAfter(inputs.source, length.end, inputs.travel.bounds, []) !== undefined || markBefore(head, inputs.travel.bounds, BOUND_GAP) !== undefined;
+};
+
+/** 移動の時間を書いた長さか。同じ文に移動の語があり、上限として書いたものではない。 */
+const isTravel = (inputs: ConnectionInputs, line: Line, length: TravelLength): boolean => {
+  const sentence = sentenceAround(line.text, length.start - line.start, length.end - line.start);
+  return mentionsTravel(line.text.slice(sentence.start, sentence.end), inputs.travel.cues) && !isBound(inputs, line, length);
+};
+
+/** 時刻の前の、同じ行に書いた最後の日付。 */
+const dateOf = (inputs: ConnectionInputs, line: Line, time: TimeSpan): string | undefined =>
+  inputs.dates.filter((date) => date.start >= line.start && date.end <= time.start).at(-1)?.value;
+
+const shiftOf = (inputs: ConnectionInputs, line: Line, time: TimeSpan): number =>
+  dayShiftOf(inputs.source.slice(line.start, time.start), inputs.source, time.end, inputs.words);
+
+const written = (inputs: ConnectionInputs, span: { start: number; end: number }): string => inputs.source.slice(span.start, span.end);
+
+type Leg = { readonly from: TimeSpan; readonly to: TimeSpan };
+
+const issueOf = (inputs: ConnectionInputs, leg: Leg, length: TravelLength): StructureIssue => ({
+  offset: leg.to.start,
+  values: {
+    time: written(inputs, leg.to),
+    from: written(inputs, leg.from),
+    gap: Math.round((leg.to.seconds - leg.from.seconds) / SECONDS_PER_MINUTE),
+    travel: written(inputs, length),
+  },
+});
+
+const dayOf = (inputs: ConnectionInputs, line: Line): readonly Stop[] | undefined =>
+  inputs.days.find((stops) => stops.some((stop) => stop.offset >= line.start && stop.offset <= line.start + line.text.length));
+
+const OPENERS = new Set(["(", "（"]);
+const CLOSERS = new Set([")", "）"]);
+
+/** at から to までを囲む一番内側の括弧の中身の範囲（行の頭からの位置）。囲む括弧が無ければ undefined。 */
+export const bracketAround = (text: string, at: number, to: number): { start: number; end: number } | undefined => {
+  const open = text
+    .slice(0, at)
+    .split("")
+    .reduceRight<{ depth: number; found: number | undefined }>(
+      (scan, char, index) => {
+        if (scan.found !== undefined) return scan;
+        if (CLOSERS.has(char)) return { ...scan, depth: scan.depth + 1 };
+        if (!OPENERS.has(char)) return scan;
+        return scan.depth === 0 ? { ...scan, found: index } : { ...scan, depth: scan.depth - 1 };
+      },
+      { depth: 0, found: undefined },
+    ).found;
+  if (open === undefined) return undefined;
+  const close = text
+    .slice(to)
+    .split("")
+    .findIndex((char) => CLOSERS.has(char));
+  return close === -1 ? undefined : { start: open + 1, end: to + close };
+};
+
+/**
+ * 移動そのものを書いた予定か。頭に時刻を書いた予定で、移動の語が括弧の外（行の本文）にある。長さを囲む括弧の中に移動の語が
+ * あれば（「（福岡空港から地下鉄で約10分）」）、その括弧はこの予定までの移動を添えたもので、予定は移動ではない。
+ */
+const isMoveLine = (inputs: ConnectionInputs, line: Line, length: TravelLength): boolean => {
+  const aside = bracketAround(line.text, length.start - line.start, length.end - line.start);
+  if (aside !== undefined && mentionsTravel(line.text.slice(aside.start, aside.end), inputs.travel.cues)) return false;
+  return dayOf(inputs, line) !== undefined && mentionsTravel(outsideBrackets(line.text), inputs.travel.cues);
+};
+
+/** 移動そのものを書いた予定の時刻と、同じ日の次の予定の時刻。 */
+const scheduledLeg = (inputs: ConnectionInputs, line: Line): Leg | undefined => {
+  const day = dayOf(inputs, line);
+  const index = day?.findIndex((stop) => stop.offset >= line.start) ?? -1;
+  const [start, next] = [day?.[index], day?.[index + 1]];
+  if (start === undefined || next === undefined || start.shift !== 0 || next.shift !== 0 || start.zone.startsWith("local:")) return undefined;
+  const timeAt = (offset: number): TimeSpan | undefined => inputs.times.find((time) => time.start === offset);
+  const [from, to] = [timeAt(start.offset), timeAt(next.offset)];
+  return from === undefined || to === undefined ? undefined : { from, to };
+};
+
+/** 時刻と同じ並び（続いた箇条書きや表の行）か同じ行にある、その時刻より前の時刻。 */
+const timesBeside = (inputs: ConnectionInputs, line: Line, to: TimeSpan): TimeSpan[] => {
+  const run = runsOf(inputs.source).find((lines) => lines.some((row) => row.start === line.start));
+  const inScope = (time: TimeSpan): boolean =>
+    (time.start >= line.start && time.end <= to.start) || (run?.some((row) => time.start >= row.start && time.end <= row.end) ?? false);
+  return inputs.times.filter((time) => time.end <= to.start && inScope(time));
+};
+
+/** 日付を書いた時刻なら、文書のそれより前の同じ日付の時刻。日付が無ければ、同じ並びか同じ行の、日付の無い前の時刻。 */
+const timesBefore = (inputs: ConnectionInputs, lines: readonly Line[], line: Line, to: TimeSpan): TimeSpan[] => {
+  const date = dateOf(inputs, line, to);
+  const candidates = date === undefined ? timesBeside(inputs, line, to) : inputs.times.filter((time) => time.end <= to.start);
+  return candidates.filter((time) => {
+    const own = lineAt(lines, time.start);
+    return own !== undefined && isSameDate(dateOf(inputs, own, time), date);
+  });
+};
+
+/**
+ * 移動の時間を添えた時刻。予定の行ならその頭の時刻、文なら移動の文の中かその後ろの、最初の着でない時刻。
+ * 移動の文より前の時刻は、移動の前の予定で、移動して着く先ではない。
+ */
+const arrivalTarget = (inputs: ConnectionInputs, line: Line, length: TravelLength): TimeSpan | undefined => {
+  const stop = dayOf(inputs, line)?.find((candidate) => candidate.offset >= line.start && candidate.offset <= line.start + line.text.length);
+  if (stop !== undefined) return inputs.times.find((time) => time.start === stop.offset);
+  const sentenceStart = line.start + sentenceAround(line.text, length.start - line.start, length.end - line.start).start;
+  return inputs.times.find((time) => time.start >= sentenceStart && time.end <= line.start + line.text.length && !inputs.arrivals.has(time.start));
+};
+
+/** 移動の時間を添えた時刻と、そのすぐ前の着の時刻。すぐ前の時刻が着でなければ、どこから移動したのか分からない。 */
+const arrivingLeg = (inputs: ConnectionInputs, lines: readonly Line[], line: Line, length: TravelLength): Leg | undefined => {
+  const to = arrivalTarget(inputs, line, length);
+  if (to === undefined) return undefined;
+  const from = timesBefore(inputs, lines, line, to).at(-1);
+  const fromLine = from === undefined ? undefined : lineAt(lines, from.start);
+  if (from === undefined || fromLine === undefined || !inputs.arrivals.has(from.start)) return undefined;
+  if (shiftOf(inputs, fromLine, from) !== 0 || shiftOf(inputs, line, to) !== 0 || !isSameZone(fromLine.text, line.text, inputs.words)) return undefined;
+  return { from, to };
+};
+
+/** 移動の時間を書いた長さごとに、間の足りない乗り継ぎ。同じ時刻は一度だけ言う。 */
+export const shortConnections = (inputs: ConnectionInputs): StructureIssue[] => {
+  const lines = linesOf(inputs.source);
+  const issues = inputs.lengths.flatMap((length) => {
+    const line = lineAt(lines, length.start);
+    if (line === undefined || !isTravel(inputs, line, length)) return [];
+    const leg = isMoveLine(inputs, line, length) ? scheduledLeg(inputs, line) : arrivingLeg(inputs, lines, line, length);
+    return leg !== undefined && isTooShort(leg.to.seconds - leg.from.seconds, length.minutes) ? [issueOf(inputs, leg, length)] : [];
+  });
+  return issues
+    .filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index)
+    .toSorted((left, right) => left.offset - right.offset);
+};

package/src/structure/counted-amounts.ts

@@ -0,0 +1,42 @@
+import type { Amount } from "./total.ts";
+
+/**
+ * 数を足してよい助数詞（16単位、4コマ、3 credits）が付いた数。解析器が助数詞と読まない語（単位、コマ）もここで数量にする。
+ * 助数詞の語は total-mismatch の語彙表（summed-counter）から取る。同じ組（group）の語（credit と credits）は同じ単位として足す。
+ */
+export type SummedCounter = { readonly pattern: string; readonly unit: string };
+
+/** 前に英字や数や小数点が続く数（v2、A4、1.2.3 の 2）は読まない。日本語は数の前に空白を置かないので、仮名や漢字の後ろはよい。 */
+const NUMBER = /(?<![\p{Script=Latin}\p{N}.,．，])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
+
+/** 助数詞に文字や数、つなぎの - _ が詰めて続くもの（3単位目、4コマ漫画、3 unit-priced）は、別の語の一部。 */
+const CONTINUES_WORD = /^[\p{L}\p{N}_-]/u;
+
+/** 序数の印（第3回）。 */
+const ORDINAL_MARK = "第";
+
+/** 助数詞を探す長さ。どの助数詞よりも長い。 */
+const LOOKAHEAD = 32;
+
+const valueOf = (written: string): number => Number(written.normalize("NFKC").replace(/,/gu, ""));
+
+/** 数のすぐ後ろ（空白一つまで）の助数詞。長い語から試す。大文字小文字は区別しない（4 Credits）。 */
+const counterAfter = (source: string, end: number, counters: readonly SummedCounter[]): { unit: string; end: number } | undefined => {
+  const gap = source.charAt(end) === " " ? 1 : 0;
+  const rest = source.slice(end + gap, end + gap + LOOKAHEAD).toLowerCase();
+  const counter = counters.find((candidate) => rest.startsWith(candidate.pattern.toLowerCase()) && !CONTINUES_WORD.test(rest.slice(candidate.pattern.length)));
+  return counter === undefined ? undefined : { unit: counter.unit, end: end + gap + counter.pattern.length };
+};
+
+const overlapsAny = (start: number, end: number, amounts: readonly Amount[]): boolean => amounts.some((amount) => start < amount.end && amount.offset < end);
+
+/** 文書の中の、足してよい助数詞の付いた数。木がすでに数量として読んだもの（known）とは重ねない。 */
+export const countedAmounts = (source: string, counters: readonly SummedCounter[], known: readonly Amount[]): Amount[] => {
+  const longestFirst = counters.toSorted((left, right) => right.pattern.length - left.pattern.length);
+  return [...source.matchAll(NUMBER)].flatMap((match): Amount[] => {
+    if (source.charAt(match.index - 1) === ORDINAL_MARK) return [];
+    const found = counterAfter(source, match.index + match[0].length, longestFirst);
+    if (found === undefined || overlapsAny(match.index, found.end, known)) return [];
+    return [{ offset: match.index, end: found.end, value: valueOf(match[0]), unit: found.unit }];
+  });
+};

package/src/structure/date-order-tie.ts

@@ -0,0 +1,86 @@
+import { versionsAlong } from "./version-order.ts";
+
+/**
+ * 隣どうしの二つの日付が入れ替わったように見えて、どちらを取り除いても同じだけ揃う（引き分け）とき、同じ項目の手がかりで決める。
+ * 項目がみな版を持ち、版が向きに沿って並ぶなら、並びの位置は版が裏付ける。位置に照らして逆らう相手の多い日付を指す。
+ * 版が無いか、版も乱れているなら、二つだけが入れ替わった並びに限り、外側の隣（前の日付の前、後ろの日付の後ろ）から遠いほうを指す。書き間違えた日付は隣から跳ぶ。
+ * どちらでも決まらなければ undefined（呼ぶ側はこれまでどおり後ろを指す）。
+ */
+export type TieEntry = { readonly value: string; readonly version: string | undefined };
+
+const DAY_MS = 86_400_000;
+const MONTHS_PER_YEAR = 12;
+/** 年の無い月日（09-14）を日数にするための、閏年の仮の年。 */
+const LEAP_YEAR = 2000;
+
+/** 同じ書き方の日付どうしで差をとれる数。年月日と月日は日数、年月は月数。 */
+const pointOf = (value: string): number | undefined => {
+  const full = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(value);
+  if (full !== null) return Date.UTC(Number(full[1]), Number(full[2]) - 1, Number(full[3])) / DAY_MS;
+  const month = /^(\d{4})-(\d{2})$/u.exec(value);
+  if (month !== null) return Number(month[1]) * MONTHS_PER_YEAR + Number(month[2]);
+  const day = /^(\d{2})-(\d{2})$/u.exec(value);
+  return day === null ? undefined : Date.UTC(LEAP_YEAR, Number(day[1]) - 1, Number(day[2])) / DAY_MS;
+};
+
+/** 位置に照らして向きに逆らう相手の数。 */
+const disagreements = (values: readonly string[], index: number, direction: number): number =>
+  values.filter((other, at) => {
+    if (at === index) return false;
+    const [earlier, later] = at < index ? [other, values[index] ?? ""] : [values[index] ?? "", other];
+    return Math.sign(later.localeCompare(earlier)) === -direction;
+  }).length;
+
+/** 多いほうを指す。同じなら決めない。 */
+const larger = (before: number, after: number, scores: readonly [number, number]): number | undefined => {
+  if (scores[0] === scores[1]) return undefined;
+  return scores[0] > scores[1] ? before : after;
+};
+
+const byVersion = (entries: readonly TieEntry[], before: number, after: number, direction: number): number | undefined => {
+  if (
+    !versionsAlong(
+      entries.map((entry) => entry.version),
+      direction,
+    )
+  )
+    return undefined;
+  const values = entries.map((entry) => entry.value);
+  return larger(before, after, [disagreements(values, before, direction), disagreements(values, after, direction)]);
+};
+
+const distance = (entries: readonly TieEntry[], from: number, to: number): number | undefined => {
+  const start = pointOf(entries[from]?.value ?? "");
+  const end = pointOf(entries[to]?.value ?? "");
+  return start === undefined || end === undefined ? undefined : Math.abs(end - start);
+};
+
+/** from から to へ、向きに逆らわない（等しくてもよい）。 */
+const along = (from: string, to: string, direction: number): boolean => Math.sign(to.localeCompare(from)) !== -direction;
+
+/** 隣どうしの入れ替わりだけ: 外側の二つが向きに沿い、入れ替わった二つがどちらもその間に収まる。乱れが広い並びでは、外側の隣も当てにならない。 */
+const isSwap = (values: readonly string[], before: number, after: number, direction: number): boolean => {
+  const [outerBefore, outerAfter] = [values[before - 1], values[after + 1]];
+  if (outerBefore === undefined || outerAfter === undefined) return false;
+  return [values[before] ?? "", values[after] ?? ""].every((value) => along(outerBefore, value, direction) && along(value, outerAfter, direction));
+};
+
+const byGap = (entries: readonly TieEntry[], before: number, after: number, direction: number): number | undefined => {
+  if (
+    !isSwap(
+      entries.map((entry) => entry.value),
+      before,
+      after,
+      direction,
+    )
+  )
+    return undefined;
+  const outerBefore = distance(entries, before - 1, before);
+  const outerAfter = distance(entries, after, after + 1);
+  if (outerBefore === undefined || outerAfter === undefined) return undefined;
+  return larger(before, after, [outerBefore, outerAfter]);
+};
+
+/** 引き分けの二つ（before = at - 1、after = at）のうち外れたほう。決まらなければ undefined。 */
+export const breakDateTie = (entries: readonly TieEntry[], before: number, after: number, direction: number): number | undefined =>
+  byVersion(entries, before, after, direction) ?? byGap(entries, before, after, direction);

package/src/structure/date-order.ts

@@ -1,9 +1,13 @@
 import type { StructureIssue } from "./issues.ts";
-import { runsOf, type Line } from "./runs.ts";
+import { siblingHeadingRunsOf } from "./heading-runs.ts";
+import { runsOf } from "./runs.ts";
+import { breakDateTie, type TieEntry } from "./date-order-tie.ts";
+import { leadingVersion } from "./version-order.ts";
 
 /**
- * 日程として並べた日付の順番。箇条書きの続いた項目か、表の続いた行で、日付をちょうど一つ持つものを並びとして読む。
- * 並びの向き（古い順か新しい順か）は多いほうで決め、それに逆らう一歩だけを言う。新しい順に並べた履歴は正しい並び。
+ * 日程として並べた日付の順番。箇条書きの続いた項目、表の続いた行、同じ親の下で同じ深さに並ぶ見出しで、
+ * 日付をちょうど一つ持つものを並びとして読む。
+ * 並びの向き（古い順か新しい順か）は多いほうで決め、それに逆らう一歩ごとに、その前後のうち並びから外れた日付を言う。新しい順に並べた履歴は正しい並び。
  * 向きが決まらない並び（上がりと下がりが同じ数）は何も言わない。逆らう一歩を言えるのは、日付が 4 つ以上の並びだけになる。
  * 向きに沿って並ぶ日付が半分以下の並びは、日付でなく別のもの（名前、版）で並べた一覧として何も言わない。
  */
@@ -12,13 +16,54 @@ export type DatedPoint = { readonly offset: number; readonly value: string };
 /** 並びとして比べられる日付の書き方。年月日、年月、月日は、同じ書き方どうしでしか比べない。 */
 const PRECISIONS = [/^\d{4}-\d{2}-\d{2}$/u, /^\d{4}-\d{2}$/u, /^\d{2}-\d{2}$/u];
 
-/** 行ごとの日付。ちょうど一つの行だけを並びに入れる。二つある行（期間）はどちらを並べたのか決められない。 */
-const datedLines = (run: readonly Line[], points: readonly DatedPoint[]): DatedPoint[] =>
+/** 並びの一行（箇条書きの項目、表の行、見出し）の原文の範囲。 */
+type Span = { readonly start: number; readonly end: number };
+
+/** 見出しの深さと原文の範囲。 */
+export type HeadingSpan = Span & { readonly depth: number };
+
+/**
+ * 同じ親の下で同じ深さに並ぶ見出し（変更履歴の版ごとの見出し）。浅い見出しが来たら、それより深い並びは閉じる。
+ * 深い見出し（### 追加）は並びを切らず、親ごとに別の並びになる。
+ */
+export const siblingHeadingRuns = (headings: readonly HeadingSpan[]): HeadingSpan[][] => siblingHeadingRunsOf(headings, (heading) => heading);
+
+/** 一行のただ一つの日付。二つある行（期間）はどちらを並べたのか決められないので、並びに入れない。 */
+const onlyDateIn = (line: Span, points: readonly DatedPoint[]): DatedPoint | undefined => {
+  const inside = points.filter((point) => point.offset >= line.start && point.offset <= line.end);
+  return inside.length === 1 ? inside[0] : undefined;
+};
+
+/** 日付を一つ持つ一行。行が版で始まれば（「## 3.1.1 - 2026-05-08」「- 3.1.0 (2026-06-02)」）その版を添える。 */
+type DatedEntry = DatedPoint & Pick<TieEntry, "version">;
+
+/** 見出しの #、箇条書きの記号、表の最初の |。 */
+const LINE_MARKER = /^[ \t]*(?:#{1,6}|[-*+]|\d{1,3}[.)]|\|)?[ \t]*/u;
+
+const entryOf = (source: string, line: Span, points: readonly DatedPoint[]): DatedEntry | undefined => {
+  const date = onlyDateIn(line, points);
+  if (date === undefined) return undefined;
+  const text = source.slice(line.start, line.end);
+  return { ...date, version: leadingVersion(text.slice(LINE_MARKER.exec(text)?.[0].length ?? 0)) };
+};
+
+const datedLines = (source: string, run: readonly Span[], points: readonly DatedPoint[]): DatedEntry[] =>
   run.flatMap((line) => {
-    const inside = points.filter((point) => point.offset >= line.start && point.offset <= line.end);
-    return inside.length === 1 && inside[0] !== undefined ? [inside[0]] : [];
+    const entry = entryOf(source, line, points);
+    return entry === undefined ? [] : [entry];
   });
 
+/** 見出しの並びは、日付を一つ持つ見出しが続くあいだだけ。日付の無い見出しが混じる並び（問いに更新日を添えた FAQ）は、日付で並べたものではない。 */
+const datedStretches = (source: string, run: readonly Span[], points: readonly DatedPoint[]): DatedEntry[][] =>
+  run.reduce<DatedEntry[][]>(
+    (stretches, heading) => {
+      const date = entryOf(source, heading, points);
+      if (date === undefined) return [...stretches, []];
+      return [...stretches.slice(0, -1), [...(stretches.at(-1) ?? []), date]];
+    },
+    [[]],
+  );
+
 const samePrecision = (dated: readonly DatedPoint[]): boolean => PRECISIONS.some((pattern) => dated.every((point) => pattern.test(point.value)));
 
 /** 上がりが多ければ 1、下がりが多ければ -1、同じ数なら 0（向きを決めない）。 */
@@ -37,23 +82,55 @@ export const longestInOrder = (values: readonly string[], direction: number): nu
 /** 日付のうち向きに沿うものが過半を占める。ひとつふたつの書き間違いなら残りが揃うが、名前順の一覧は揃わない。 */
 const mostlyInOrder = (values: readonly string[], direction: number): boolean => longestInOrder(values, direction) * 2 > values.length;
 
-/** 多いほうの向きに逆らう一歩。後ろの項目の日付を指す。 */
-const againstMajority = (dated: readonly DatedPoint[]): StructureIssue[] => {
-  const steps = dated
-    .slice(1)
-    .map((point, index) => ({ point, previous: dated[index], sign: Math.sign(point.value.localeCompare(dated[index]?.value ?? "")) }));
-  const up = steps.filter((step) => step.sign > 0).length;
-  const down = steps.filter((step) => step.sign < 0).length;
-  const majority = majorityOf(up, down);
+const without = (values: readonly string[], index: number): string[] => values.filter((_, at) => at !== index);
+
+/**
+ * 向きに逆らう一歩（at - 1 から at）のうち、並びから外れているほう。取り除いたとき残りが長く揃うほうを指す。
+ * 前を取っても後ろを取っても同じだけ揃う（隣どうしの入れ替わり）なら、tieBreak が決めたほう、決まらなければ後ろを指す。
+ */
+export const outOfPlace = (
+  values: readonly string[],
+  at: number,
+  direction: number,
+  tieBreak: (before: number, after: number) => number | undefined = () => undefined,
+): number => {
+  const withoutBefore = longestInOrder(without(values, at - 1), direction);
+  const withoutAfter = longestInOrder(without(values, at), direction);
+  if (withoutBefore === withoutAfter) return tieBreak(at - 1, at) ?? at;
+  return withoutBefore > withoutAfter ? at - 1 : at;
+};
+
+/** 外れた日付に、前の日付を添える。先頭の日付には前が無いので、次の日付を添える。 */
+const issueAt = (dated: readonly DatedPoint[], at: number): StructureIssue[] => {
+  const point = dated[at];
+  if (point === undefined) return [];
+  const neighbour = at === 0 ? { next: dated[1]?.value ?? "" } : { previous: dated[at - 1]?.value ?? "" };
+  return [{ offset: point.offset, values: { date: point.value, ...neighbour } }];
+};
+
+/** 多いほうの向きに逆らう一歩ごとに、並びから外れた日付を指す。 */
+const againstMajority = (dated: readonly DatedEntry[]): StructureIssue[] => {
   const values = dated.map((point) => point.value);
+  const signs = values.slice(1).map((value, index) => Math.sign(value.localeCompare(values[index] ?? "")));
+  const majority = majorityOf(signs.filter((sign) => sign > 0).length, signs.filter((sign) => sign < 0).length);
   if (majority === 0 || !mostlyInOrder(values, majority)) return [];
-  return steps
-    .filter((step) => step.sign === -majority)
-    .map((step) => ({ offset: step.point.offset, values: { date: step.point.value, previous: step.previous?.value ?? "" } }));
+  return signs.flatMap((sign, index) => {
+    if (sign !== -majority) return [];
+    return issueAt(
+      dated,
+      outOfPlace(values, index + 1, majority, (before, after) => breakDateTie(dated, before, after, majority)),
+    );
+  });
 };
 
-export const dateOrderBreaks = (source: string, points: readonly DatedPoint[]): StructureIssue[] =>
-  runsOf(source).flatMap((run) => {
-    const dated = datedLines(run, points);
-    return samePrecision(dated) ? againstMajority(dated) : [];
-  });
+const breaksIn = (dated: readonly DatedEntry[]): StructureIssue[] => (samePrecision(dated) ? againstMajority(dated) : []);
+
+/** 見出しを箇条書きの中に書けば（「- ## 3.1.0 - 2026-10-02」）、同じ日付が両方の並びに入る。一度だけ言う。 */
+const oncePerOffset = (issues: readonly StructureIssue[]): StructureIssue[] =>
+  issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
+
+export const dateOrderBreaks = (source: string, points: readonly DatedPoint[], headings: readonly HeadingSpan[] = []): StructureIssue[] =>
+  oncePerOffset([
+    ...runsOf(source).flatMap((run) => breaksIn(datedLines(source, run, points))),
+    ...siblingHeadingRuns(headings).flatMap((run) => datedStretches(source, run, points).flatMap(breaksIn)),
+  ]);