chaffjs 0.29.0 → 0.31.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

@@ -7,10 +7,10 @@ import type { Amount } from "./total.ts";
 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;
+export 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;
+export const CONTINUES_WORD = /^[\p{L}\p{N}_-]/u;
 
 /** 序数の印（第3回）。 */
 const ORDINAL_MARK = "第";
@@ -18,7 +18,7 @@ const ORDINAL_MARK = "第";
 /** 助数詞を探す長さ。どの助数詞よりも長い。 */
 const LOOKAHEAD = 32;
 
-const valueOf = (written: string): number => Number(written.normalize("NFKC").replace(/,/gu, ""));
+export 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 => {
@@ -28,7 +28,8 @@ const counterAfter = (source: string, end: number, counters: readonly SummedCoun
   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);
+export 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[] => {

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,6 +1,8 @@
 import type { StructureIssue } from "./issues.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";
 
 /**
  * 日程として並べた日付の順番。箇条書きの続いた項目、表の続いた行、同じ親の下で同じ深さに並ぶ見出しで、
@@ -32,17 +34,30 @@ const onlyDateIn = (line: Span, points: readonly DatedPoint[]): DatedPoint | und
   return inside.length === 1 ? inside[0] : undefined;
 };
 
-const datedLines = (run: readonly Span[], points: readonly DatedPoint[]): DatedPoint[] =>
+/** 日付を一つ持つ一行。行が版で始まれば（「## 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 date = onlyDateIn(line, points);
-    return date === undefined ? [] : [date];
+    const entry = entryOf(source, line, points);
+    return entry === undefined ? [] : [entry];
   });
 
 /** 見出しの並びは、日付を一つ持つ見出しが続くあいだだけ。日付の無い見出しが混じる並び（問いに更新日を添えた FAQ）は、日付で並べたものではない。 */
-const datedStretches = (run: readonly Span[], points: readonly DatedPoint[]): DatedPoint[][] =>
-  run.reduce<DatedPoint[][]>(
+const datedStretches = (source: string, run: readonly Span[], points: readonly DatedPoint[]): DatedEntry[][] =>
+  run.reduce<DatedEntry[][]>(
     (stretches, heading) => {
-      const date = onlyDateIn(heading, points);
+      const date = entryOf(source, heading, points);
       if (date === undefined) return [...stretches, []];
       return [...stretches.slice(0, -1), [...(stretches.at(-1) ?? []), date]];
     },
@@ -71,10 +86,19 @@ const without = (values: readonly string[], index: number): string[] => values.f
 
 /**
  * 向きに逆らう一歩（at - 1 から at）のうち、並びから外れているほう。取り除いたとき残りが長く揃うほうを指す。
- * 前を取っても後ろを取っても同じだけ揃う（隣どうしの入れ替わり）なら、どちらとも決められないので後ろを指す。
+ * 前を取っても後ろを取っても同じだけ揃う（隣どうしの入れ替わり）なら、tieBreak が決めたほう、決まらなければ後ろを指す。
  */
-export const outOfPlace = (values: readonly string[], at: number, direction: number): number =>
-  longestInOrder(without(values, at - 1), direction) > longestInOrder(without(values, at), direction) ? at - 1 : at;
+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[] => {
@@ -85,18 +109,21 @@ const issueAt = (dated: readonly DatedPoint[], at: number): StructureIssue[] =>
 };
 
 /** 多いほうの向きに逆らう一歩ごとに、並びから外れた日付を指す。 */
-const againstMajority = (dated: readonly DatedPoint[]): StructureIssue[] => {
+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 signs.flatMap((sign, index) => {
     if (sign !== -majority) return [];
-    return issueAt(dated, outOfPlace(values, index + 1, majority));
+    return issueAt(
+      dated,
+      outOfPlace(values, index + 1, majority, (before, after) => breakDateTie(dated, before, after, majority)),
+    );
   });
 };
 
-const breaksIn = (dated: readonly DatedPoint[]): StructureIssue[] => (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[] =>
@@ -104,6 +131,6 @@ const oncePerOffset = (issues: readonly StructureIssue[]): StructureIssue[] =>
 
 export const dateOrderBreaks = (source: string, points: readonly DatedPoint[], headings: readonly HeadingSpan[] = []): StructureIssue[] =>
   oncePerOffset([
-    ...runsOf(source).flatMap((run) => breaksIn(datedLines(run, points))),
-    ...siblingHeadingRuns(headings).flatMap((run) => datedStretches(run, points).flatMap(breaksIn)),
+    ...runsOf(source).flatMap((run) => breaksIn(datedLines(source, run, points))),
+    ...siblingHeadingRuns(headings).flatMap((run) => datedStretches(source, run, points).flatMap(breaksIn)),
   ]);

package/src/structure/date-outside-period.ts

@@ -1,6 +1,7 @@
 import { escapeRegExp } from "../orthography.ts";
 import type { StructureIssue } from "./issues.ts";
 import { TABLE_ROW } from "./runs.ts";
+import { deadlineVerdict } from "./term-deadline.ts";
 import { statedPeriod, type DateMention, type Period, type PeriodWords } from "./stated-period.ts";
 
 /**
@@ -8,11 +9,21 @@ import { statedPeriod, type DateMention, type Period, type PeriodWords } from ".
  * 地の文の日付は、年の無いもの（2月12日（金）の午前は…）だけを比べる。年のある日付は、過去の回や別の年の出来事を挙げることが多い。
  * 期間の前後に置く予定（前泊、follow-up）、締め切りや予約の日、過去の回を言う語（period-aside）が、その行、文、節の見出しにあれば比べない。
  * 年の無い期間（12月28日〜1月4日）は年をまたいで読む。
+ * 文書の仕事の期間（開講期間：…）を文書の頭か概要の節で書いたものは文書全体の期間で、後ろのどの節でも、締め切りの語（period-deadline）のある項目や文の、
+ * 期間の終わりより後の日付を指す（課題の提出が学期の後）。年の無い日付は、期間が一つの年に収まるときだけその年と読む。成績発表や再試験の語（period-after-term）のある日付は比べない。期間の前の締め切り（申込締切）と、旅行期間のように後に締め切りが来てよい期間は比べない。
  */
 export type HeadingSpan = { readonly start: number; readonly end: number; readonly depth: number };
 type Span = { readonly start: number; readonly end: number };
 
-export type OutsideWords = PeriodWords & { readonly asides: readonly string[] };
+export type OutsideWords = PeriodWords & {
+  readonly asides: readonly string[];
+  /** 文書の仕事がその中で済む期間の語（開講期間、Term）。この期間は締め切りとだけ比べる。 */
+  readonly terms: readonly string[];
+  readonly deadlines: readonly string[];
+  readonly overviews: readonly string[];
+  /** 期間の後に来てよい仕事の語（成績発表、再試験）。この語のある締め切りは期間と比べない。 */
+  readonly afterTerm: readonly string[];
+};
 
 const LIST_ITEM = /^[ \t]{0,12}(?:[-*+]|\d{1,3}[.)])[ \t]/u;
 const DAY_VALUE = /^(?:\d{4}-)?\d{2}-\d{2}$/u;
@@ -46,7 +57,7 @@ export const mentions = (text: string, words: readonly string[]): boolean => {
   });
 };
 
-type Stated = Period & { readonly scopeStart: number; readonly scopeEnd: number };
+type Stated = Period & { readonly line: Span; readonly scopeStart: number; readonly scopeEnd: number; readonly nextPeriod: number };
 
 /**
  * 期間の及ぶ範囲の始まり: 期間の行の後ろ。期間の行が箇条書きの項目なら、その箇条書きの後ろ。
@@ -84,6 +95,8 @@ const statedPeriods = (
   });
   return found.map(({ period, line }, index) => ({
     ...period,
+    line,
+    nextPeriod: found[index + 1]?.line.start ?? source.length,
     scopeStart: scopeStart(source, lines, line),
     scopeEnd: scopeEnd(line, found[index + 1]?.line.start ?? source.length, headings, source.length),
   }));
@@ -110,6 +123,65 @@ const outsideOne = (date: DateMention, period: Stated, context: Context, asides:
   return !surroundings(date, line, item, context).some((text) => mentions(text, asides));
 };
 
+const boundaryPattern = (word: string): RegExp => {
+  const target = escapeRegExp(word.toLowerCase());
+  return /[a-z]/u.test(word.toLowerCase()) ? new RegExp(`(?<![a-z])${target}(?![a-z])`, "gu") : new RegExp(target, "gu");
+};
+
+/** 締め切りの語を除いた文。「提出期限」の「期限」、「submit by」の「submit」は、期間の外に置く語として読まない。 */
+const withoutWords = (text: string, words: readonly string[]): string =>
+  words.toSorted((left, right) => right.length - left.length).reduce((rest, word) => rest.replace(boundaryPattern(word), " "), text.toLowerCase());
+
+/** 節の見出しの並び（その行の見出しと、それを囲む浅い見出し）。 */
+const enclosingHeadings = (offset: number, headings: readonly HeadingSpan[]): HeadingSpan[] =>
+  headings
+    .filter((heading) => heading.start < offset)
+    .toReversed()
+    .reduce<HeadingSpan[]>((chain, heading) => (heading.depth < (chain.at(-1)?.depth ?? Infinity) ? [...chain, heading] : chain), []);
+
+/** 文書の仕事の期間か: 表題（文書の頭の # の見出し）のほかの見出しより前か、概要の節（period-overview-heading）の行。 */
+const isDocumentTerm = (period: Stated, context: Context, overviews: readonly string[]): boolean => {
+  const sections = context.headings.filter((heading, index) => heading.start < period.line.start && !(index === 0 && heading.depth === 1));
+  if (sections.length === 0) return true;
+  return enclosingHeadings(period.line.start, context.headings).some((heading) => mentions(context.source.slice(heading.start, heading.end), overviews));
+};
+
+const lateDeadline = (date: DateMention, period: Stated, context: Context, words: OutsideWords): boolean => {
+  if (!DAY_VALUE.test(date.value)) return false;
+  const line = containing(context.lines, date.offset);
+  if (line === undefined) return false;
+  const texts = surroundings(date, line, isItem(context.source.slice(line.start, line.end), line, context.headings), context);
+  const marks = {
+    deadline: mentions(texts[0] ?? "", words.deadlines),
+    aside: texts.some((text) => mentions(withoutWords(text, words.deadlines), words.asides)),
+    afterTerm: mentions(texts[0] ?? "", words.afterTerm),
+  };
+  return deadlineVerdict(date.value, period, marks) === "late";
+};
+
+const issueOf = (source: string, date: DateMention, period: Stated): StructureIssue => ({
+  offset: date.offset,
+  values: { date: source.slice(date.offset, date.end), period: period.written },
+});
+
+/** 期間の行の後ろ、同じ節の日程の日付で、期間の外のもの。 */
+const outsideInSection = (dates: readonly DateMention[], context: Context, words: OutsideWords): StructureIssue[] =>
+  statedPeriods(context.source, context.lines, dates, context.headings, words).flatMap((period) =>
+    dates
+      .filter((date) => date.offset > period.scopeStart && date.offset < period.scopeEnd && outsideOne(date, period, context, words.asides))
+      .map((date) => issueOf(context.source, date, period)),
+  );
+
+/** 文書の仕事の期間の行の後ろ、次の仕事の期間の行までの、期間の終わりより後の締め切り。 */
+const lateDeadlines = (dates: readonly DateMention[], context: Context, words: OutsideWords): StructureIssue[] =>
+  statedPeriods(context.source, context.lines, dates, context.headings, { ...words, labels: words.terms })
+    .filter((period) => isDocumentTerm(period, context, words.overviews))
+    .flatMap((period) =>
+      dates
+        .filter((date) => date.offset > period.line.end && date.offset < period.nextPeriod && lateDeadline(date, period, context, words))
+        .map((date) => issueOf(context.source, date, period)),
+    );
+
 export const datesOutsidePeriod = (
   source: string,
   dates: readonly DateMention[],
@@ -119,9 +191,7 @@ export const datesOutsidePeriod = (
 ): StructureIssue[] => {
   const lines = linesOf(source);
   const context: Context = { source, lines, headings, sentences };
-  return statedPeriods(source, lines, dates, headings, words).flatMap((period) =>
-    dates
-      .filter((date) => date.offset > period.scopeStart && date.offset < period.scopeEnd && outsideOne(date, period, context, words.asides))
-      .map((date) => ({ offset: date.offset, values: { date: source.slice(date.offset, date.end), period: period.written } })),
-  );
+  const inSection = outsideInSection(dates, context, words);
+  const reported = new Set(inSection.map((issue) => issue.offset));
+  return [...inSection, ...lateDeadlines(dates, context, words).filter((issue) => !reported.has(issue.offset))];
 };