chaffjs 0.28.0 → 0.30.0

package/src/facts/condition-pairs.ts

@@ -0,0 +1,289 @@
+import type { Span, Token } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { comparable, sameValue, type FactValue } from "./fact-values.ts";
+
+/**
+ * 要約の「XからYに」（"from X to Y"）を、本文が二つの条件（前と後、無いときとあるとき、2025年と2026年）で書いた同じ項目の二つの値と
+ * 組にして比べる。項目の名前が本文の文にあり、二つの値の条件がどちらも読めたときだけ比べる。言語の知識（から、to、前、after）は
+ * 語彙表から取る。
+ */
+export type WordAt = { readonly pattern: string; readonly position: "before" | "after" };
+export type ConditionWord = { readonly pattern: string; readonly group: string };
+
+export type ChangeWords = {
+  /** もとの値に付く語（from、から）。 */
+  readonly from: readonly WordAt[];
+  /** 動いた先の値に付く語（to、に）。 */
+  readonly to: readonly WordAt[];
+  /** 名前と変化のあいだにあれば、変化ではなく幅を言う語（"ranges from 0 to 10"）。 */
+  readonly notChange: readonly string[];
+  /** 名前と値のあいだで飛ばす語（は、が）。 */
+  readonly subjectMarks: readonly string[];
+  /** 名前の語をつなぐ語（の、of）。position が after の語（の）は、前の語が後ろの語を修飾する。短い名前はその前の語を書かないことがある（「無いときの誤りの率」の「誤りの率」）。 */
+  readonly joiners: readonly WordAt[];
+  /** もとの側の条件（before、無いとき）と、動いた先の側の条件（after、あるとき）。同じ group の語どうしが組になる。 */
+  readonly conditionsFrom: readonly ConditionWord[];
+  readonly conditionsTo: readonly ConditionWord[];
+};
+
+export type ChangeSentence = { readonly span: Span; readonly text: string; readonly tokens: readonly Token[]; readonly summary: boolean };
+
+/** 名前（subject）の付いた、もとの値と先の値の組。names は同じ項目を指す名前の書き方（修飾を落とした短い名前も）。 */
+export type ValuePair = {
+  readonly subject: string;
+  readonly key: string;
+  readonly names: readonly string[];
+  readonly from: FactValue;
+  readonly to: FactValue;
+};
+
+export type PairConflict = { readonly summary: ValuePair; readonly body: ValuePair };
+
+const LATIN = /^[A-Za-z]/u;
+const SPACES = /\s+/gu;
+/** 暦の年（2025、2026年）。条件として読み、値としては読まない。日付の一部（2011-10-26、2025年10月）は年の条件ではない。 */
+const YEAR = /(?<![\d.,/-])(?:1[89]|2[01])\d{2}(?![\d.,%/-]|年\d)/gu;
+
+const squeezed = (text: string): string => text.replace(SPACES, "").toLowerCase();
+
+/** 語の現れる所。英字の語は語の切れ目で、ほかは書いたとおりに探す。 */
+const wordSpans = (text: string, word: string, offset: number): Span[] => {
+  const pattern = LATIN.test(word) ? new RegExp(`\\b${escapeRegExp(word)}\\b`, "giu") : new RegExp(escapeRegExp(word), "gu");
+  return [...text.matchAll(pattern)].map((match) => ({ start: offset + match.index, end: offset + match.index + match[0].length }));
+};
+
+const endsWithWord = (text: string, word: string): boolean => {
+  const lowered = text.trimEnd().toLowerCase();
+  if (!lowered.endsWith(word.toLowerCase())) return false;
+  return !LATIN.test(word) || !/[A-Za-z]$/u.test(lowered.slice(0, lowered.length - word.length));
+};
+
+const startsWithWord = (text: string, word: string): boolean => {
+  const lowered = text.trimStart().toLowerCase();
+  if (!lowered.startsWith(word.toLowerCase())) return false;
+  return !LATIN.test(word) || !/^[A-Za-z]/u.test(lowered.slice(word.length));
+};
+
+const patternsAt = (words: readonly WordAt[], position: WordAt["position"]): string[] =>
+  words.filter((word) => word.position === position).map((word) => word.pattern);
+
+/** 二つの値のあいだが、もとの値の後ろの語と先の値の前の語だけか（" to "、「から」）。 */
+const joinsChange = (between: string, words: ChangeWords): boolean => {
+  const fromAfter = ["", ...patternsAt(words.from, "after")];
+  const toBefore = ["", ...patternsAt(words.to, "before")];
+  const shown = squeezed(between);
+  return shown !== "" && fromAfter.some((first) => toBefore.some((second) => squeezed(first + second) === shown));
+};
+
+/** 前に要る語（from）があれば、その語の始まり。要らなければ値の始まり。無ければ undefined。 */
+const changeStart = (source: string, value: FactValue, words: ChangeWords): number | undefined => {
+  const before = patternsAt(words.from, "before");
+  if (before.length === 0) return value.start;
+  const head = source.slice(0, value.start);
+  const found = before.find((word) => endsWithWord(head, word));
+  return found === undefined ? undefined : head.trimEnd().length - found.length;
+};
+
+const TAIL_LENGTH = 40;
+
+const endsChange = (source: string, value: FactValue, words: ChangeWords): boolean => {
+  const after = patternsAt(words.to, "after");
+  const tail = source.slice(value.end, value.end + TAIL_LENGTH);
+  return after.length === 0 || after.some((word) => startsWithWord(tail, word));
+};
+
+const isYear = (source: string, value: FactValue): boolean => value.unit === "" && /^(?:1[89]|2[01])\d{2}$/u.test(source.slice(value.start, value.end));
+
+const isQuantityPair = (source: string, from: FactValue, to: FactValue): boolean =>
+  from.kind === "quantity" && comparable(from, to) && !isYear(source, from) && !isYear(source, to);
+
+const isBlank = (token: Token): boolean => token.surface.trim() === "";
+const SKIPPED: ReadonlySet<string> = new Set(["VERB", "AUX", "ADV"]);
+const NAME_WORD: ReadonlySet<string> = new Set(["NOUN", "PROPN", "ADJ"]);
+const HEAD_WORD: ReadonlySet<string> = new Set(["NOUN", "PROPN"]);
+const DIGIT = /\d/u;
+
+const isSkipped = (token: Token, marks: ReadonlySet<string>): boolean => isBlank(token) || marks.has(token.surface) || SKIPPED.has(token.pos);
+
+const joinerSet = (words: ChangeWords): ReadonlySet<string> => new Set(words.joiners.map((word) => word.pattern.toLowerCase()));
+
+const isNameToken = (token: Token, joiners: ReadonlySet<string>): boolean =>
+  (NAME_WORD.has(token.pos) && !DIGIT.test(token.surface)) || joiners.has(token.surface.toLowerCase());
+
+const keyOf = (text: string): string => text.normalize("NFKC").toLowerCase().replace(SPACES, " ");
+
+/** 名前の並びを、つなぐ語で始まらず名詞で終わるところまで切る。 */
+const trimmedName = (run: readonly Token[], joiners: ReadonlySet<string>): Token[] => {
+  const named = run.slice(
+    Math.max(
+      0,
+      run.findIndex((token) => !joiners.has(token.surface.toLowerCase())),
+    ),
+  );
+  return named.slice(0, named.findLastIndex((token) => HEAD_WORD.has(token.pos)) + 1);
+};
+
+/** 一つの名前の書き方: 全体と、修飾の語（「無いときの」）を前から落としたもの。 */
+const namesOf = (source: string, named: readonly Token[], words: ChangeWords): string[] => {
+  const last = named.at(-1);
+  if (last === undefined) return [];
+  const dropping = new Set(words.joiners.filter((word) => word.position === "after").map((word) => word.pattern.toLowerCase()));
+  const starts = [0, ...named.flatMap((token, index) => (dropping.has(token.surface.toLowerCase()) ? [index + 1] : []))];
+  return starts.flatMap((start) => {
+    const first = named[start];
+    return first === undefined ? [] : [keyOf(source.slice(first.span.start, last.span.end))];
+  });
+};
+
+/** 文の中の名前の並び（名詞と、つなぐ語でつながる語）ごとの、名前の書き方。 */
+const namesIn = (source: string, sentence: ChangeSentence, words: ChangeWords): Set<string> => {
+  const joiners = joinerSet(words);
+  const runs = sentence.tokens.reduce<Token[][]>((found, token, index) => {
+    if (!isNameToken(token, joiners)) return found;
+    const previous = sentence.tokens[index - 1];
+    const current = previous !== undefined && isNameToken(previous, joiners) ? found.at(-1) : undefined;
+    if (current === undefined) found.push([token]);
+    else current.push(token);
+    return found;
+  }, []);
+  return new Set(runs.flatMap((run) => namesOf(source, trimmedName(run, joiners), words)));
+};
+
+/**
+ * 変化の前の名前の語の並び（"error rate"、「誤りの率」）。その前の空白、は・が、動詞（"the rate fell from"）は飛ばす。
+ * つなぐ語で始まらず、名詞で終わる。
+ */
+const nameTokens = (tokens: readonly Token[], words: ChangeWords): Token[] => {
+  const marks = new Set(words.subjectMarks);
+  const joiners = joinerSet(words);
+  const head = tokens.slice(0, tokens.findLastIndex((token) => !isSkipped(token, marks)) + 1);
+  const run = head.slice(head.findLastIndex((token) => !isNameToken(token, joiners)) + 1);
+  const named = trimmedName(run, joiners);
+  return HEAD_WORD.has(run.at(-1)?.pos ?? "") ? named : [];
+};
+
+type Subject = { readonly subject: string; readonly key: string; readonly names: readonly string[] };
+
+const subjectBefore = (source: string, sentence: ChangeSentence, offset: number, words: ChangeWords): Subject | undefined => {
+  const named = nameTokens(
+    sentence.tokens.filter((token) => token.span.end <= offset),
+    words,
+  );
+  const [first, last] = [named[0], named.at(-1)];
+  if (first === undefined || last === undefined) return undefined;
+  const subject = source.slice(first.span.start, last.span.end);
+  const gap = source.slice(last.span.end, offset);
+  if (words.notChange.some((word) => wordSpans(gap, word, 0).length > 0)) return undefined;
+  return { subject, key: keyOf(subject), names: namesOf(source, named, words) };
+};
+
+/** 文の中の「XからYに」と、その前の名前。 */
+const changesIn = (source: string, sentence: ChangeSentence, values: readonly FactValue[], words: ChangeWords): ValuePair[] =>
+  values.slice(0, -1).flatMap((from, index): ValuePair[] => {
+    const to = values[index + 1];
+    if (to === undefined || !isQuantityPair(source, from, to) || !joinsChange(source.slice(from.end, to.start), words)) return [];
+    const start = changeStart(source, from, words);
+    if (start === undefined || !endsChange(source, to, words)) return [];
+    const named = subjectBefore(source, sentence, start, words);
+    return named === undefined ? [] : [{ ...named, from, to }];
+  });
+
+type Mark = Span & { readonly side: "from" | "to"; readonly group: string; readonly year?: number };
+
+const conditionMarks = (sentence: ChangeSentence, words: readonly ConditionWord[], side: Mark["side"]): Mark[] =>
+  words.flatMap((word) => wordSpans(sentence.text, word.pattern, sentence.span.start).map((span): Mark => ({ ...span, side, group: word.group })));
+
+const yearMarks = (sentence: ChangeSentence): Mark[] =>
+  [...sentence.text.matchAll(YEAR)].map((match) => {
+    const start = sentence.span.start + match.index;
+    return { start, end: start + match[0].length, side: "from", group: "year", year: Number(match[0]) };
+  });
+
+const overlaps = (left: Span, right: Span): boolean => left.start < right.end && right.start < left.end;
+
+/** 年の組は、早い年がもとの側。違う年がちょうど二つのときだけ。 */
+const yearPair = (marks: readonly Mark[]): Mark[] | undefined => {
+  const years = marks.filter((mark) => mark.group === "year");
+  const [first, second] = years;
+  if (years.length !== 2 || first === undefined || second === undefined || first.year === second.year) return undefined;
+  const later = (first.year ?? 0) < (second.year ?? 0) ? second : first;
+  return years.map((mark) => (mark === later ? { ...mark, side: "to" } : mark));
+};
+
+/** 一つの組の語が、もとの側と先の側に一つずつ。そういう組がちょうど一つのときだけ、その二つ。 */
+const conditionPair = (marks: readonly Mark[]): Mark[] | undefined => {
+  const groups = [...new Set(marks.map((mark) => mark.group))];
+  const pairs = groups.flatMap((group) => {
+    if (group === "year") return [yearPair(marks)].filter((pair) => pair !== undefined);
+    const inGroup = marks.filter((mark) => mark.group === group);
+    const sides = new Set(inGroup.map((mark) => mark.side));
+    return inGroup.length === 2 && sides.size === 2 ? [inGroup] : [];
+  });
+  return pairs.length === 1 ? pairs[0] : undefined;
+};
+
+const CLAUSE_BREAK = /[,;、，；]/u;
+
+/** 二つの範囲のあいだに、句の切れ目（, ; 、）がある。 */
+const brokenBetween = (sentence: ChangeSentence, left: Span, right: Span): boolean =>
+  CLAUSE_BREAK.test(sentence.text.slice(left.end - sentence.span.start, right.start - sentence.span.start));
+
+/**
+ * 条件と値が、条件・値・条件・値か、値・条件・値・条件の順に並び、二組のあいだが句の切れ目で分かれるときだけ、どの値がどの条件の
+ * ものか決まる。切れ目が無いと（"With breaks, against 2.4% without them, … 1.6%"）、条件が前と後ろのどちらの値に付くか決まらない。
+ */
+const pairByOrder = (sentence: ChangeSentence, conditions: readonly Mark[], values: readonly FactValue[]): { from: FactValue; to: FactValue } | undefined => {
+  const [c1, c2] = conditions.toSorted((left, right) => left.start - right.start);
+  const [v1, v2] = values;
+  if (c1 === undefined || c2 === undefined || v1 === undefined || v2 === undefined) return undefined;
+  const leads = c1.end <= v1.start && v1.end <= c2.start && c2.end <= v2.start && brokenBetween(sentence, v1, c2);
+  const follows = v1.end <= c1.start && c1.end <= v2.start && v2.end <= c2.start && brokenBetween(sentence, c1, v2);
+  if (!leads && !follows) return undefined;
+  return c1.side === "from" ? { from: v1, to: v2 } : { from: v2, to: v1 };
+};
+
+/** 本文の一文が、名前と、比べられる二つの値と、その二つの条件を書いていれば、その組。 */
+const conditionedPair = (sentence: ChangeSentence, values: readonly FactValue[], summary: ValuePair, words: ChangeWords): ValuePair | undefined => {
+  const marks = [...conditionMarks(sentence, words.conditionsFrom, "from"), ...conditionMarks(sentence, words.conditionsTo, "to"), ...yearMarks(sentence)];
+  const free = marks.filter((mark) => mark.group === "year" || !values.some((value) => overlaps(mark, value)));
+  const measured = values.filter((value) => comparable(summary.from, value) && !free.some((mark) => overlaps(mark, value)));
+  const conditions = conditionPair(free);
+  if (measured.length !== 2 || conditions === undefined) return undefined;
+  const pair = pairByOrder(sentence, conditions, measured);
+  return pair === undefined ? undefined : { ...summary, ...pair };
+};
+
+const within = (span: Span, values: readonly FactValue[]): FactValue[] => values.filter((value) => value.start >= span.start && value.end <= span.end);
+
+const samePair = (left: ValuePair, right: ValuePair): boolean => sameValue(left.from, right.from) && sameValue(left.to, right.to);
+
+/** 本文の組。本文に書いた「XからYに」と、条件で分けて書いた二つの値。 */
+const bodyPairs = (source: string, sentences: readonly ChangeSentence[], values: readonly FactValue[], summary: ValuePair, words: ChangeWords): ValuePair[] =>
+  sentences
+    .filter((sentence) => !sentence.summary)
+    .flatMap((sentence) => {
+      const inside = within(sentence.span, values);
+      const changes = changesIn(source, sentence, inside, words).filter((change) => change.names.includes(summary.key));
+      const conditioned = namesIn(source, sentence, words).has(summary.key) ? conditionedPair(sentence, inside, summary, words) : undefined;
+      return [...changes, ...(conditioned === undefined ? [] : [conditioned])];
+    })
+    .filter((pair) => comparable(summary.from, pair.from) && comparable(summary.to, pair.to));
+
+/** 要約の「XからYに」が、本文で一通りに書いた同じ名前の組と違う。本文の組が無いか二通り以上なら言わない。 */
+export const conditionPairConflicts = (
+  source: string,
+  sentences: readonly ChangeSentence[],
+  values: readonly FactValue[],
+  words: ChangeWords,
+): PairConflict[] =>
+  sentences
+    .filter((sentence) => sentence.summary)
+    .flatMap((sentence) => changesIn(source, sentence, within(sentence.span, values), words))
+    .flatMap((summary) => {
+      const distinct = bodyPairs(source, sentences, values, summary, words).reduce<ValuePair[]>(
+        (kept, pair) => (kept.some((seen) => samePair(seen, pair)) ? kept : [...kept, pair]),
+        [],
+      );
+      const [only] = distinct;
+      return distinct.length !== 1 || only === undefined || samePair(summary, only) ? [] : [{ summary, body: only }];
+    });

package/src/facts/event-dates.ts

@@ -0,0 +1,63 @@
+import type { Span } from "../plugin.ts";
+import { sameValue, type FactValue } from "./fact-values.ts";
+
+/**
+ * 出来事の日付。文が出来事の語（提供、release）を一つの組だけ含み、日付を一つだけ持つとき、その日付をその出来事の日付と読む。
+ * 冒頭や要約の文の日付を、本文の同じ組の出来事の日付と比べる。本文の日付が一通りに揃っていて、違うときだけ言う。
+ * 年月日まで書いた日付どうしだけを比べる。日付が二つある文（期間）や、組が二つある文（発表した日と提供する日）は読まない。
+ * 本文の文が、冒頭の文に無い名前（別の製品、別の催し）を持つなら、別の出来事として比べない。
+ */
+export type EventWord = { readonly pattern: string; readonly group: string };
+
+/** names: 文の中の固有名詞などの名前。 */
+export type EventSentence = Span & { readonly text: string; readonly summary: boolean; readonly names: readonly string[] };
+
+export type EventDateConflict = { readonly label: string; readonly value: FactValue; readonly other: FactValue };
+
+type EventDate = { readonly group: string; readonly label: string; readonly value: FactValue; readonly sentence: EventSentence };
+
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
+
+const normalized = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const startsWord = (text: string, at: number): boolean => at === 0 || !/[a-z]/u.test(text.charAt(at - 1));
+
+/** 文の中の出来事の語。英字の語は語の頭からだけ（releases は release、prerelease は違う）。 */
+const wordsIn = (text: string, words: readonly EventWord[]): EventWord[] => {
+  const folded = normalized(text);
+  return words.filter((word) => {
+    const pattern = normalized(word.pattern);
+    const at = folded.indexOf(pattern);
+    return at >= 0 && (!/^[a-z]/u.test(pattern) || startsWord(folded, at));
+  });
+};
+
+const inside = (sentence: Span, value: Span): boolean => sentence.start <= value.start && value.end <= sentence.end;
+
+const eventDateOf = (sentence: EventSentence, dates: readonly FactValue[], words: readonly EventWord[]): EventDate[] => {
+  const own = dates.filter((date) => inside(sentence, date));
+  const found = wordsIn(sentence.text, words);
+  const groups = new Set(found.map((word) => word.group));
+  const [date, word] = [own[0], found[0]];
+  if (own.length !== 1 || groups.size !== 1 || date === undefined || word === undefined || !FULL_DATE.test(date.key)) return [];
+  return [{ group: word.group, label: word.pattern, value: date, sentence }];
+};
+
+const distinct = (values: readonly FactValue[]): FactValue[] =>
+  values.reduce<FactValue[]>((kept, value) => (kept.some((seen) => sameValue(seen, value)) ? kept : [...kept, value]), []);
+
+/** 本文の文の名前が、どれも冒頭の文にある（名前の無い「提供開始日は」も同じ出来事と読む）。 */
+const sameSubject = (event: EventDate, other: EventDate): boolean => other.sentence.names.every((name) => event.sentence.names.includes(name));
+
+const conflictOf = (event: EventDate, body: readonly EventDate[]): EventDateConflict[] => {
+  const values = distinct(body.filter((other) => other.group === event.group && sameSubject(event, other)).map((other) => other.value));
+  const only = values.length === 1 ? values[0] : undefined;
+  return only === undefined || sameValue(event.value, only) ? [] : [{ label: event.label, value: event.value, other: only }];
+};
+
+/** 冒頭や要約の出来事の日付が、本文で揃って書かれた同じ出来事の日付と違う。dates は日付の値だけ。 */
+export const eventDateConflicts = (sentences: readonly EventSentence[], dates: readonly FactValue[], words: readonly EventWord[]): EventDateConflict[] => {
+  const events = sentences.flatMap((sentence) => eventDateOf(sentence, dates, words));
+  const body = events.filter((event) => !event.sentence.summary);
+  return events.filter((event) => event.sentence.summary).flatMap((event) => conflictOf(event, body));
+};

package/src/facts/fact-scope.ts

@@ -139,3 +139,9 @@ export const scopedFacts = (facts: readonly Fact[], tree: StructureNode, source:
       return { ...fact, ...scopeOf(fact, around.at(-1), at), part: partOf(around, tree, fact.value.start, summaryWords) };
     });
 };
+
+/** 文書のその位置が、冒頭、要約の節、本文のどれか。 */
+export const partsAt = (offsets: readonly number[], tree: StructureNode, summaryWords: readonly string[]): FactPart[] => {
+  const nodes = inDocumentOrder(tree).filter((node) => CONTAINERS.has(node.kind));
+  return offsets.map((offset) => partOf(containersAt(nodes, offset), tree, offset, summaryWords));
+};

package/src/facts/labelled-facts.ts

@@ -19,6 +19,8 @@ export type FactWords = {
   readonly determiners: readonly string[];
   /** 名前にならない語（それ、it）。 */
   readonly vague: readonly string[];
+  /** 名前の前に置かれる決定の前置き（協議の結果、, it was decided that）。読点を含んでも条件ではないので、外してから名前を読む。 */
+  readonly leads: readonly string[];
   readonly attributes: readonly AttributePhrase[];
 };
 
@@ -38,6 +40,7 @@ const LETTER = /\p{L}/u;
 /** 名前に書かない記号。コードや属性（{style="…"}、"key"=）の中の値は、項目の値ではない。 */
 const CODE_MARK = /[{}<>=[\]"`]/u;
 const LATIN_WORD = /^[a-z ]+$/iu;
+const LATIN_LETTER = /^[a-z]$/iu;
 
 const lineStartOf = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
 
@@ -54,6 +57,15 @@ const beforeSeparator = (head: string, separator: string): string | undefined =>
   return rest;
 };
 
+/** 英字の前置きが語の途中で切れているか（「we agreed that」は「we agreed thatching」の頭ではない）。 */
+const endsInsideWord = (text: string, length: number): boolean => LATIN_LETTER.test(text.charAt(length - 1)) && LATIN_LETTER.test(text.charAt(length));
+
+/** 頭の決定の前置きを外した節。 */
+const withoutLead = (clause: string, words: FactWords): string => {
+  const lead = words.leads.find((phrase) => clause.toLowerCase().startsWith(phrase.toLowerCase()) && !endsInsideWord(clause, phrase.length));
+  return lead === undefined ? clause : clause.slice(lead.length).trimStart();
+};
+
 /** 最後の文の切れ目より後ろ。 */
 const afterLastBreak = (text: string): string => {
   const breaks = [...text.matchAll(SENTENCE_BREAK)];
@@ -97,7 +109,7 @@ const labelledFact = (source: string, value: FactValue, words: FactWords): Fact
   for (const separator of words.separators) {
     const before = beforeSeparator(head, separator);
     if (before === undefined) continue;
-    const clause = afterLastBreak(before).replace(BLOCK_MARK, "").replace(ITEM_MARK, "");
+    const clause = withoutLead(afterLastBreak(before).replace(BLOCK_MARK, "").replace(ITEM_MARK, "").trimStart(), words);
     if (CLAUSE_COMMA.test(clause)) return undefined;
     const label = withoutEdgeMarks(clause);
     const key = keyOf(label, words);

package/src/facts/table-facts.ts

@@ -11,12 +11,12 @@ import { withoutEdgeMarks } from "./trim-marks.ts";
  * 升に値だけを書いたときだけ読む。「3,000円（税込）」のように条件を書いた升は読まない。
  * 行の見出しが値を含むか字を含まない表（日付の列から始まる日程表）は、行に名前が無いので読まない。
  */
-type Cell = Span & { readonly text: string };
+export type Cell = Span & { readonly text: string };
 
 const LETTER = /\p{L}/u;
 const TWO_COLUMNS = 2;
 
-const cellsOf = (line: Line): Cell[] => {
+export const cellsOf = (line: Line): Cell[] => {
   const bounds = [-1, ...[...line.text.matchAll(CELL_SEPARATOR)].map((match) => match.index), line.text.length];
   const cells = bounds.slice(1).map((end, index) => {
     const from = (bounds[index] ?? 0) + 1;
@@ -29,7 +29,7 @@ const cellsOf = (line: Line): Cell[] => {
 const plain = withoutEdgeMarks;
 
 /** 区切り行（|---|）の前の行が見出し、後ろに続く | の行が本体。 */
-const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] =>
+export const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] =>
   lines.flatMap((line, index) => {
     const header = lines[index - 1];
     if (!TABLE_RULE.test(line.text) || header === undefined || !header.text.includes("|")) return [];
@@ -69,3 +69,6 @@ export const tableFacts = (source: string, values: readonly FactValue[]): Fact[]
     const headings = cellsOf(table.header).map((cell) => plain(cell.text));
     return table.rows.flatMap((row) => rowFacts(row, headings, values, source));
   });
+
+/** 文書の表すべての、本体の行の升（見出しの行を除く）。text は書いたまま。 */
+export const tableBodyCells = (source: string): Cell[] => tablesOf(linesOf(source)).flatMap((table) => table.rows.flatMap(cellsOf));

package/src/grade/ai-score.ts

@@ -8,7 +8,7 @@ export type GradeAiScore = {
   readonly notScored: NotScored["reason"] | null;
   readonly signs: number;
   readonly compared: number;
-  /** The signs that counted: rule ids, and structure measures as structure:<id>. */
+  /** The signs that counted: rule ids, structure measures as structure:<id>, and ai-generated-composite:strict. */
   readonly shown: readonly string[];
 };
 

package/src/grade/text.ts

@@ -103,7 +103,7 @@ const aside = (open: string, inner: string, close: string): string => (inner ===
 export const GRADE_TEXT: Texts<GradeText> = {
   ja: {
     usage:
-      "使い方: chaff grade <items.jsonl> [--out <results.jsonl>] [--baseline <前の results.jsonl>] [--variant-key <欄の名前>] [--format text|json|markdown] [--json] [--compact] [--experimental] [--genre <ジャンル>]",
+      "使い方: chaff grade <items.jsonl> [--out <results.jsonl>] [--baseline <前の results.jsonl>] [--allow-stamp-mismatch] [--variant-key <欄の名前>] [--format text|json|markdown] [--json] [--compact] [--experimental] [--genre <ジャンル>]",
     noReference: "reference が無い（事実は reference と照らす）",
     noCitations: "citations が無い（chaff は出力から引用を推測しない）",
     noContexts: "contexts が無い（回答の事実は、検索で取った一節と照らす）",
@@ -135,7 +135,7 @@ export const GRADE_TEXT: Texts<GradeText> = {
   },
   en: {
     usage:
-      "usage: chaff grade <items.jsonl> [--out <results.jsonl>] [--baseline <earlier results.jsonl>] [--variant-key <field>] [--format text|json|markdown] [--json] [--compact] [--experimental] [--genre <genre>]",
+      "usage: chaff grade <items.jsonl> [--out <results.jsonl>] [--baseline <earlier results.jsonl>] [--allow-stamp-mismatch] [--variant-key <field>] [--format text|json|markdown] [--json] [--compact] [--experimental] [--genre <genre>]",
     noReference: "no reference given (facts are checked against a reference)",
     noCitations: "no citations given (chaff does not guess quotations from the output)",
     noContexts: "no contexts given (the output's facts are checked against retrieved passages)",

package/src/heading-numbering.ts

@@ -11,8 +11,8 @@ const ARABIC = "[0-9０-９]+";
 const KANJI = "[一二三四五六七八九十百]+";
 const ROMAN = "[IVXⅠ-Ⅻ]+";
 
-/** 番号の後ろに続く見出しの言葉の頭。字で始まる。「8.2.3 (2026-08-06)」の版や「3 reasons」の数量は番号と読まない。 */
-const WORDS_FOLLOW = "(?=\\s*[\\p{L}])";
+/** 番号の後ろに続く見出しの言葉の頭。字か、コードや引用の開き（`check()`、「概要」）で始まる。「8.2.3 (2026-08-06)」の版や「3 reasons」の数量は番号と読まない。 */
+const WORDS_FOLLOW = '(?=\\s*[\\p{L}`「『“"])';
 
 /**
  * 字だけで決まる書き方。上から順に試す。ラテン文字一字とローマ数字（A. と II.）は同じ書き方とする。どちらも番号の後ろに言葉が続くときだけ。

package/src/html/fetch-page.ts

@@ -0,0 +1,64 @@
+// Fetches a page as text, in the encoding it declares, with a timeout. A non-2xx answer throws an error whose cause
+// carries the HTTP status, so a caller can tell a dead page (404) from a transient one (503). Every error names the URL.
+import { decodeFetched } from "./fetched-text.ts";
+
+export class HttpStatusError extends Error {
+  readonly status: number;
+
+  constructor(status: number) {
+    super(`HTTP ${String(status)}`);
+    this.status = status;
+  }
+}
+
+/** The page's text and the Content-Type it was sent with (null when it had none). */
+export type FetchedPage = { readonly text: string; readonly contentType: string | null };
+
+/** What fetches: the global fetch, or a stand-in in tests. */
+export type Fetcher = (url: string, init: { readonly signal: AbortSignal }) => Promise<Response>;
+
+export type FetchLimits = {
+  readonly timeout_ms: number;
+  /** A body longer than this is refused while it is read, before it is decoded. Undefined: no limit. */
+  readonly max_bytes?: number | undefined;
+};
+
+const tooLarge = (max_bytes: number): Error => new Error(`the page is larger than ${String(max_bytes)} bytes`);
+
+/** A read that gave bytes; a finished read (done) is not one. */
+const isChunk = (read: unknown): read is { readonly value: Uint8Array } =>
+  typeof read === "object" && read !== null && Reflect.get(read, "done") !== true && Reflect.get(read, "value") instanceof Uint8Array;
+
+/** The body's bytes, stopping as soon as they pass max_bytes. */
+const bodyBytes = async (response: Response, max_bytes: number | undefined): Promise<Uint8Array> => {
+  if (max_bytes === undefined || response.body === null) return new Uint8Array(await response.arrayBuffer());
+  const declared = Number(response.headers.get("content-length") ?? Number.NaN);
+  if (declared > max_bytes) throw tooLarge(max_bytes);
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  for (let read: unknown = await reader.read(); isChunk(read); read = await reader.read()) {
+    size += read.value.byteLength;
+    if (size > max_bytes) {
+      await reader.cancel();
+      throw tooLarge(max_bytes);
+    }
+    chunks.push(read.value);
+  }
+  return Buffer.concat(chunks);
+};
+
+export const fetchPage = async (url: string, limits: FetchLimits, fetcher: Fetcher = fetch): Promise<FetchedPage> => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), limits.timeout_ms);
+  try {
+    const response = await fetcher(url, { signal: controller.signal });
+    if (!response.ok) throw new HttpStatusError(response.status);
+    const contentType = response.headers.get("content-type");
+    return { text: decodeFetched(await bodyBytes(response, limits.max_bytes), contentType), contentType };
+  } catch (err) {
+    throw new Error(`${url}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+  } finally {
+    clearTimeout(timer);
+  }
+};

package/src/html/fetched-text.ts

@@ -0,0 +1,32 @@
+// The text of a fetched body in the encoding it declares: the Content-Type header first, then a <meta charset> or an
+// XML declaration near the top of an HTML or XML body, otherwise UTF-8. Many Japanese government pages are still
+// Shift_JIS. Pure.
+
+/** How far into the body a declaration is looked for; HTML requires <meta charset> within the first 1024 bytes. */
+const DECLARATION_BYTES = 1024;
+
+const CHARSET = /charset\s*=\s*["']?([\w.:-]+)/iu;
+
+const declaredInHead = (head: string): string | undefined =>
+  /<meta\b[^>]*\bcharset\s*=\s*["']?([\w.:-]+)/iu.exec(head)?.[1] ?? /^\s*<\?xml\b[^>]*\bencoding\s*=\s*["']([\w.:-]+)["']/iu.exec(head)?.[1];
+
+/** Only a markup body can declare its own encoding; Markdown or JSON that quotes a <meta> tag declares nothing. */
+const isMarkup = (contentType: string | null): boolean => contentType === null || /html|xml/iu.test(contentType);
+
+/** The label the body declares, lower-cased, or "utf-8" when it declares none. */
+export const charsetOf = (contentType: string | null, head: string): string =>
+  (CHARSET.exec(contentType ?? "")?.[1] ?? (isMarkup(contentType) ? declaredInHead(head) : undefined) ?? "utf-8").toLowerCase();
+
+const decoderFor = (label: string): TextDecoder => {
+  try {
+    return new TextDecoder(label);
+  } catch {
+    return new TextDecoder("utf-8");
+  }
+};
+
+/** An unknown label is read as UTF-8, as before a declaration was looked for. */
+export const decodeFetched = (bytes: Uint8Array, contentType: string | null): string => {
+  const head = new TextDecoder("latin1").decode(bytes.subarray(0, DECLARATION_BYTES));
+  return decoderFor(charsetOf(contentType, head)).decode(bytes);
+};