chaffjs 0.33.0 → 0.35.0

package/src/facts/per-unit.ts

@@ -0,0 +1,105 @@
+import type { FactValue } from "./fact-values.ts";
+import { columnUnitAt, columnUnits, UNIT_PRICE, type HeadingUnitWords } from "./column-units.ts";
+
+/**
+ * 値が何あたりか（1kmあたり15円、毎月5,000円、$0.45 per mile、日額5,000円）。単位が量（時間、日、月、km、mile。語彙表 rate-unit）の
+ * 値は、その量を掛けて金額になる単価なので、同じ単位あたりの値とだけ比べる。1kmあたり15円 と 表の 1,650円 は別の量。
+ * 件や回ごと（1件につき220円、for each transfer）は量ではない。手数料の表は 1件分 を印なしで書く（| 振込手数料 | 165円 |）ので、
+ * 何あたりとは読まず、これまでどおり比べる。決まった印（日額、/km、a day）は語彙表 per-unit-mark が単位まで言う。
+ * 型（*あたり、毎*、per *）は * に rate-unit の単位の語（日 は day）を入れた句だけを読む。型の position は値のどちら側に書くか。
+ */
+export type PerUnitMark = { readonly pattern: string; readonly group: string };
+
+export type PerUnitTemplate = { readonly pattern: string; readonly position: "before" | "after" };
+
+export type PerUnitWords = {
+  /** 単位まで決まった印（日額、/km、a day）。group が単位。 */
+  readonly marks: readonly PerUnitMark[];
+  /** * が単位の語の型（*あたり、毎*、per *）。 */
+  readonly templates: readonly PerUnitTemplate[];
+  /** 量の単位の語と、それが数える単位（日 は day）。ここに無い語（件、回）は何あたりとは読まない。 */
+  readonly units: readonly PerUnitMark[];
+  /** 百分率の単位（%）。率の期間（年4.8%）は率の基準（rate-values）が見て、期間を書かない率とも比べるので、ここでは読まない。 */
+  readonly percentUnits: readonly string[];
+  /** 単価の列の見出し（単価、Unit price、時給）。その列の升は、見出しの単位あたりの値（column-units.ts）。 */
+  readonly priceHeadings: readonly { readonly pattern: string; readonly group?: string }[];
+};
+
+const PLACEHOLDER = "*";
+/** 印を探す、値の前と後ろの字数。「日額」「1日あたり」が値の前の数字の前に書かれる。 */
+const MARK_REACH = 24;
+/** 値の前の型と値のあいだに置ける字（空白、読点。畳んだ後の字）。1kmあたり、15円。 */
+const GAP_CHARS: ReadonlySet<string> = new Set([" ", "、", ","]);
+const LETTER_OR_DIGIT = /[\p{L}\p{N}]/u;
+const LETTER = /\p{L}/u;
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
+
+const withoutGapAtEnd = (text: string): string => (GAP_CHARS.has(text.slice(-1)) ? withoutGapAtEnd(text.slice(0, -1)) : text);
+
+/** 型の * に単位の語を入れた句と、その単位。* の無い型は単位を言わないので、句にならない。 */
+type Phrase = { readonly text: string; readonly group: string; readonly unitFirst: boolean };
+
+const phrasesOf = (template: PerUnitTemplate, units: readonly PerUnitMark[]): Phrase[] => {
+  const pattern = folded(template.pattern);
+  const at = pattern.indexOf(PLACEHOLDER);
+  if (at === -1) return [];
+  return units.map((unit) => ({ text: `${pattern.slice(0, at)}${folded(unit.pattern)}${pattern.slice(at + 1)}`, group: unit.group, unitFirst: at === 0 }));
+};
+
+/** 印がちょうど値の後ろに始まり、語の途中で切れていない（per mile は per milestone の頭ではない）。 */
+const startsAfter = (after: string, text: string): boolean => after.startsWith(text) && !LETTER_OR_DIGIT.test(after.charAt(text.length));
+
+/** 印がちょうど値の前で終わる。単位の語で始まる句は、前が字でない（1日につき の 日。利用日につき の 日 ではない）。 */
+const endsBefore = (before: string, text: string, unitFirst: boolean): boolean =>
+  before.endsWith(text) && !(unitFirst && LETTER.test(before.charAt(before.length - text.length - 1)));
+
+const longest = (groups: readonly { readonly length: number; readonly group: string }[]): string | undefined =>
+  groups.reduce<{ readonly length: number; readonly group: string } | undefined>(
+    (best, match) => (best === undefined || match.length > best.length ? match : best),
+    undefined,
+  )?.group;
+
+/** 値のすぐ後ろ（$100 a day、5,000円/日）かすぐ前（日額5,000円）の、決まった印の単位。 */
+const markOf = (before: string, after: string, marks: readonly PerUnitMark[]): string | undefined =>
+  marks.find((mark) => startsAfter(after, folded(mark.pattern)))?.group ?? marks.find((mark) => before.endsWith(folded(mark.pattern)))?.group;
+
+/** 値の前（1kmあたり15円、毎月5,000円）か後ろ（$0.45 per mile）の型の単位。当たる句が二つあれば長いほう（か月 と 月）。 */
+const templateOf = (before: string, after: string, words: PerUnitWords): string | undefined =>
+  longest(
+    words.templates.flatMap((template) =>
+      phrasesOf(template, words.units)
+        .filter((phrase) => (template.position === "before" ? endsBefore(before, phrase.text, phrase.unitFirst) : startsAfter(after, phrase.text)))
+        .map((phrase) => ({ length: phrase.text.length, group: phrase.group })),
+    ),
+  );
+
+/** 値が何の量あたりか。量あたりでなければ（件ごと、印なし）undefined。 */
+export const perUnitOf = (source: string, value: FactValue, words: PerUnitWords): string | undefined => {
+  const after = folded(source.slice(value.end, value.end + MARK_REACH)).trimStart();
+  const before = withoutGapAtEnd(folded(source.slice(Math.max(0, value.start - MARK_REACH), value.start)));
+  return markOf(before, after, words.marks) ?? templateOf(before, after, words);
+};
+
+/** 列の見出しを読む語: 単価の列の語と、見出しに書く何あたりの句（決まった印と、型に単位の語を入れた句）。 */
+const headingWordsOf = (words: PerUnitWords): HeadingUnitWords => ({
+  headings: words.priceHeadings.map((heading) => ({ pattern: heading.pattern, group: heading.group ?? UNIT_PRICE })),
+  phrases: [...words.marks, ...words.templates.flatMap((template) => phrasesOf(template, words.units).map(({ text, group }) => ({ pattern: text, group })))],
+});
+
+/** 値の書き方と表の列から読む、何あたりか（per）と、表の升ならその列の見出しの単位（column）。 */
+const unitsOf = (source: string, value: FactValue, words: PerUnitWords, column: string | undefined): Pick<FactValue, "per" | "column"> => {
+  const percent = words.percentUnits.some((unit) => folded(unit) === folded(value.unit));
+  if (value.kind !== "quantity" || percent) return {};
+  const per = perUnitOf(source, value, words);
+  return { ...(per === undefined ? {} : { per }), ...(column === undefined ? {} : { column }) };
+};
+
+/** 数量の値に、何あたりか（1kmあたり15円 の km）と、表の升ならその列の見出しの単位（単価の列）を付ける。 */
+export const withPerUnits = <T extends FactValue>(source: string, values: readonly T[], words: PerUnitWords): T[] => {
+  const columns = columnUnits(source, headingWordsOf(words));
+  return values.map((value) => {
+    const units = unitsOf(source, value, words, columnUnitAt(columns, value));
+    return units.per === undefined && units.column === undefined ? value : { ...value, ...units };
+  });
+};

package/src/facts/row-sentence-amounts.ts

@@ -5,18 +5,15 @@ import { withoutEdgeMarks } from "./trim-marks.ts";
  * 表の行の金額と、その行の見出しを主語に書いた文の金額（| 治療・救援費用 | 3,000万円 | と「治療・救援費用は、5,000万円を限度に」）。
  * 文は値の前後に言い回し（入院1日につき、を限度に、is paid at）を書くので、名前付きの値（labelled-facts）としては読めない。
  * 主語が行の見出しとちょうど同じで、同じ範囲にあり、行と文のどちらにも同じ通貨の金額がちょうど一つのときだけ比べる。
- * 二つ以上あれば、どれがどれに当たるか（日額と上限）は読まないと分からないので比べない。期間あたりの印（日額、a day）が両方に
- * あって期間が違えば（日額と月額）、別の値なので比べない。
+ * 二つ以上あれば、どれがどれに当たるか（日額と上限）は読まないと分からないので比べない。何あたりの金額（日額、1kmあたり）は、
+ * 同じ何あたりの金額とだけ比べる（fact-values の comparable）。日額と月額、1kmあたりの単価とそれを掛けた金額は別の値。
  */
-/** period: 金額の前後に書いた期間あたりの印の期間（日額 の day）。 */
-export type Amount = FactValue & { readonly period?: string };
+export type Amount = FactValue;
 
 export type AmountRow = { readonly label: string; readonly scope: string; readonly amounts: readonly Amount[] };
 
 export type SubjectSentence = { readonly text: string; readonly scope: string; readonly amounts: readonly Amount[] };
 
-export type PeriodMark = { readonly pattern: string; readonly group: string };
-
 export type SubjectWords = {
   /** 主語と述べる部分の区切り（は、は、、is、are）。英字だけの区切りは、前が空白で後ろが語の切れ目のときだけ。 */
   readonly separators: readonly string[];
@@ -28,8 +25,6 @@ export type SubjectWords = {
 
 export type RowSentenceConflict = { readonly label: string; readonly value: FactValue; readonly other: FactValue };
 
-const SPACE = /^[ \t]?/u;
-const MARK_REACH = 16;
 const STRONG_MARK = /\*\*|__/gu;
 const LATIN_WORD = /^[a-z ]+$/iu;
 const LATIN_LETTER = /[a-z]/iu;
@@ -38,20 +33,6 @@ const ITEM_MARK = /^(?:[-*+]|\d{1,3}[.)])[ \t]+/u;
 
 const folded = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
 
-const markAt = (text: string, marks: readonly PeriodMark[]): string | undefined => {
-  const lowered = folded(text);
-  return marks.find((mark) => lowered.startsWith(folded(mark.pattern)))?.group;
-};
-
-const markBefore = (text: string, marks: readonly PeriodMark[]): string | undefined => {
-  const lowered = folded(text).trimEnd();
-  return marks.find((mark) => lowered.endsWith(folded(mark.pattern)))?.group;
-};
-
-/** 金額のすぐ前（日額5,000円）かすぐ後ろ（$100 a day、5,000円/日）の期間あたりの印の期間。 */
-export const periodOf = (source: string, value: FactValue, marks: readonly PeriodMark[]): string | undefined =>
-  markAt(source.slice(value.end).replace(SPACE, ""), marks) ?? markBefore(source.slice(Math.max(0, value.start - MARK_REACH), value.start), marks);
-
 const withoutDeterminer = (text: string, determiners: readonly string[]): string => {
   const word = determiners.map(folded).find((determiner) => LATIN_WORD.test(determiner) && text.startsWith(`${determiner} `));
   return word === undefined ? text : text.slice(word.length + 1);
@@ -87,13 +68,10 @@ const onlyPair = (row: AmountRow, sentence: SubjectSentence, value: Amount): Amo
   return inRow.length === 1 && inSentence.length === 1 ? inRow[0] : undefined;
 };
 
-/** 期間の違う金額（日額と月額）は別の値。片方にしか印が無ければ比べる（1日につき は語彙表に無い書き方）。 */
-const samePeriod = (left: Amount, right: Amount): boolean => left.period === undefined || right.period === undefined || left.period === right.period;
-
 const conflictsWith = (row: AmountRow, sentence: SubjectSentence): RowSentenceConflict[] =>
   sentence.amounts.flatMap((value) => {
     const other = onlyPair(row, sentence, value);
-    return other === undefined || sameValue(other, value) || !samePeriod(other, value) ? [] : [{ label: row.label, value, other }];
+    return other === undefined || sameValue(other, value) ? [] : [{ label: row.label, value, other }];
   });
 
 const rowsByScope = (rows: readonly AmountRow[]): ReadonlyMap<string, AmountRow[]> =>

package/src/facts/table-facts.ts

@@ -1,6 +1,7 @@
 import type { Span } from "../plugin.ts";
 import { linesOf, type Line } from "../structure/lines.ts";
 import { TABLE_RULE } from "../structure/runs.ts";
+import { fencedLineIndexes } from "../structure/fenced-lines.ts";
 import { CELL_SEPARATOR } from "../structure/bare-numbers.ts";
 import type { FactValue } from "./fact-values.ts";
 import type { Fact } from "./labelled-facts.ts";
@@ -29,15 +30,17 @@ export const cellsOf = (line: Line): Cell[] => {
 
 const plain = withoutEdgeMarks;
 
-/** 区切り行（|---|）の前の行が見出し、後ろに続く | の行が本体。 */
-export const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] =>
-  lines.flatMap((line, index) => {
+/** 区切り行（|---|）の前の行が見出し、後ろに続く | の行が本体。コードブロックの中の表は例なので読まない。 */
+export const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] => {
+  const fenced = fencedLineIndexes(lines.map((line) => line.text));
+  return lines.flatMap((line, index) => {
     const header = lines[index - 1];
-    if (!TABLE_RULE.test(line.text) || header === undefined || !header.text.includes("|")) return [];
+    if (fenced.has(index) || !TABLE_RULE.test(line.text) || header === undefined || !header.text.includes("|")) return [];
     const after = lines.slice(index + 1);
     const end = after.findIndex((row) => !row.text.includes("|"));
     return [{ header, rows: end === -1 ? after : after.slice(0, end) }];
   });
+};
 
 const inside = (cell: Span, value: FactValue): boolean => value.start >= cell.start && value.end <= cell.end;
 
@@ -64,18 +67,21 @@ const cellLabel = (rowLabel: string, column: string, headings: readonly string[]
   return headings.length > TWO_COLUMNS ? `${rowLabel} ${column}` : rowLabel;
 };
 
-/** 列が三つ以上の表の升は、行の見出し（row）と列の見出し（column）の二つで名前になる。 */
-export type TableFact = Fact & { readonly cell?: { readonly row: string; readonly column: string } };
+/**
+ * 列が三つ以上の表の升は、行の見出し（row）と列の見出し（column）の二つで名前になる。
+ * columnGroup: 見出しの並びを繰り返す表（Day | Hours | Day | Hours の、第1週と第2週を横に並べた表）の、何番目の並びの升か。
+ */
+export type TableFact = Fact & { readonly cell?: { readonly row: string; readonly column: string }; readonly columnGroup?: number };
 
 const rowFacts = (
-  row: Line,
+  cells: readonly Cell[],
   headings: readonly string[],
   values: readonly FactValue[],
   source: string,
   totals?: TotalColumns,
   counts?: CountLabelWords,
 ): TableFact[] => {
-  const [first, ...rest] = cellsOf(row);
+  const [first, ...rest] = cells;
   if (first === undefined) return [];
   const rowLabel = plain(first.text);
   const isCountHead = (value: FactValue): boolean => counts !== undefined && isCountLabelHead(source, first, value, counts);
@@ -91,11 +97,45 @@ const rowFacts = (
   });
 };
 
+const MIN_GROUPS = 2;
+
+/** 見出しが同じ並びを二度以上繰り返すなら、その並びの幅。並びごとに別の表として読む。 */
+export const columnGroupWidth = (headings: readonly string[]): number | undefined => {
+  const keys = headings.map(keyOf);
+  const widths = Array.from({ length: Math.floor(keys.length / MIN_GROUPS) - 1 }, (_, index) => index + TWO_COLUMNS);
+  return widths.find((width) => keys.length % width === 0 && keys[0] !== "" && keys.every((key, index) => key === keys[index % width]));
+};
+
+const groupsOf = <T>(items: readonly T[], width: number | undefined): T[][] =>
+  width === undefined ? [[...items]] : Array.from({ length: Math.ceil(items.length / width) }, (_, index) => items.slice(index * width, (index + 1) * width));
+
+/** columnGroups: 見出しを繰り返す表を、並びごとに読む（並びの升には columnGroup が付く）。 */
+export type TableReading = { readonly columnGroups?: boolean };
+
+type RowReading = { readonly values: readonly FactValue[]; readonly source: string; readonly totals?: TotalColumns; readonly counts?: CountLabelWords };
+
+/** 一つの行の升の値。見出しを繰り返す表（width がある）は、並びごとに読んで columnGroup を付ける。 */
+const groupedRowFacts = (row: Line, headings: readonly string[], width: number | undefined, at: RowReading): TableFact[] => {
+  const headingGroups = groupsOf(headings, width);
+  return groupsOf(cellsOf(row), width).flatMap((cells, group) => {
+    const facts = rowFacts(cells, headingGroups[group] ?? [], at.values, at.source, at.totals, at.counts);
+    return width === undefined ? facts : facts.map((fact) => ({ ...fact, columnGroup: group }));
+  });
+};
+
 /** 文書の表すべての升の値。 */
-export const tableFacts = (source: string, values: readonly FactValue[], totals?: TotalColumns, counts?: CountLabelWords): TableFact[] =>
+export const tableFacts = (
+  source: string,
+  values: readonly FactValue[],
+  totals?: TotalColumns,
+  counts?: CountLabelWords,
+  reading: TableReading = {},
+): TableFact[] =>
   tablesOf(linesOf(source)).flatMap((table) => {
     const headings = cellsOf(table.header).map((cell) => plain(cell.text));
-    return table.rows.flatMap((row) => rowFacts(row, headings, values, source, totals, counts));
+    const width = reading.columnGroups === true ? columnGroupWidth(headings) : undefined;
+    const at: RowReading = { values, source, ...(totals === undefined ? {} : { totals }), ...(counts === undefined ? {} : { counts }) };
+    return table.rows.flatMap((row) => groupedRowFacts(row, headings, width, at));
   });
 
 /** 文書の表すべての、本体の行の升（見出しの行を除く）。text は書いたまま。 */

package/src/facts/term-values.ts

@@ -2,6 +2,7 @@ import { sameValue, type FactValue } from "./fact-values.ts";
 import type { Fact } from "./labelled-facts.ts";
 import type { TermWord } from "./document-terms.ts";
 import { withoutEdgeMarks } from "./trim-marks.ts";
+import { qualifiedKeyOf, type QualifierWords } from "./qualified-labels.ts";
 
 /**
  * 文書全体で一つの値を持つ項目（保証期間、warranty period）を主語にした文の期間。名前付きの値の読み（labelled-facts）は、区切りの
@@ -24,6 +25,14 @@ export type TermValueWords = {
   /** 起算の句の印（から は値の前の句の終わり、from は値の後ろの句の頭）。 */
   readonly starts: readonly PlacedWord[];
   readonly valueEnds: readonly string[];
+  /** 名前のすぐ後ろで、その値を何に使ったかを言う句の頭（used for the）。後ろの句ごと落としても同じ項目。 */
+  readonly restating?: readonly string[];
+  /** 名前と値を囲む型（を*として）。* が値。型の値は、期間でなくても読む。 */
+  readonly frames?: readonly string[];
+  /** 文の値に条件を付ける語（場合、if）。型の前の句にあれば読まない。 */
+  readonly conditions?: readonly string[];
+  /** 名前に条件を付ける型（*の、for *）。 */
+  readonly qualifiers?: QualifierWords;
 };
 
 const folded = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
@@ -73,12 +82,35 @@ const withoutSelf = (key: string, words: TermValueWords): string => {
   return (self.position === "before" ? key.slice(length) : key.slice(0, key.length - length)).trim();
 };
 
-/** 名前が語彙表の項目なら、その語の形。 */
-export const termKeyOf = (label: string, words: TermValueWords): string | undefined => {
+/** 語彙表の項目の形。語彙表の語は条件の付いた名前の形（扶養親族の数 は 数 (扶養親族)）なので、名前もその形にして比べる。 */
+const termOf = (key: string, words: TermValueWords): string | undefined => {
+  const qualified = words.qualifiers === undefined ? key : qualifiedKeyOf(key, words.qualifiers);
+  return words.terms.map((word) => folded(word.pattern)).find((pattern) => pattern === key || pattern === qualified);
+};
+
+/** 何に使ったかを言う句から後ろを落とした名前（number of dependants used for the allowance の number of dependants）。 */
+const withoutRestating = (key: string, words: TermValueWords): string | undefined =>
+  (words.restating ?? [])
+    .flatMap((word) => {
+      const mark = ` ${folded(word)}`;
+      const at = key.indexOf(mark);
+      const next = key.charAt(at + mark.length);
+      return at > 0 && (next === "" || next === " ") ? [key.slice(0, at)] : [];
+    })
+    .find((head) => termOf(head, words) !== undefined);
+
+/** 名前が語彙表の項目なら、その語の形。restated: 何に使ったかを言う句を落として、項目になった。 */
+const termKeyWith = (label: string, words: TermValueWords): { readonly key: string; readonly restated: boolean } | undefined => {
   const key = withoutSelf(withoutDeterminer(folded(withoutEdgeMarks(label)), words), words);
-  return words.terms.map((word) => folded(word.pattern)).find((pattern) => pattern === key);
+  const term = termOf(key, words);
+  if (term !== undefined) return { key: term, restated: false };
+  const restated = withoutRestating(key, words);
+  return restated === undefined ? undefined : { key: restated, restated: true };
 };
 
+/** 名前が語彙表の項目なら、その語の形。 */
+export const termKeyOf = (label: string, words: TermValueWords): string | undefined => termKeyWith(label, words)?.key;
+
 type Span = { readonly start: number; readonly end: number };
 
 const valuesIn = (values: readonly FactValue[], span: Span): FactValue[] => values.filter((value) => span.start <= value.start && value.end <= span.end);
@@ -91,7 +123,7 @@ const separatorsIn = (text: string, separator: string): number[] =>
     .map((match) => match.index)
     .filter((index) => !isLatin(separator) || (text.charAt(index - 1) === " " && [" ", ""].includes(text.charAt(index + separator.length))));
 
-type Subject = { readonly key: string; readonly label: string; readonly lead: Span | undefined; readonly restStart: number };
+type Subject = { readonly key: string; readonly label: string; readonly lead: Span | undefined; readonly restStart: number; readonly restated: boolean };
 
 /** 文の頭から区切りまでの主語。読点の前は条件の句。 */
 const subjectOf = (source: string, from: number, to: number, words: TermValueWords): Subject | undefined => {
@@ -101,9 +133,10 @@ const subjectOf = (source: string, from: number, to: number, words: TermValueWor
       const head = clause.slice(0, index);
       const comma = [...head.matchAll(CLAUSE_COMMAS)].at(-1)?.index;
       const label = withoutEdgeMarks(comma === undefined ? head : head.slice(comma + 1));
-      const key = termKeyOf(label, words);
-      if (key === undefined) continue;
-      return { key, label, lead: comma === undefined ? undefined : { start: from, end: from + comma }, restStart: from + index + separator.length };
+      const term = termKeyWith(label, words);
+      if (term === undefined) continue;
+      const lead = comma === undefined ? undefined : { start: from, end: from + comma };
+      return { ...term, label, lead, restStart: from + index + separator.length };
     }
   }
   return undefined;
@@ -170,10 +203,10 @@ const isWorkedExample = (lead: Span, starts: readonly Span[], values: readonly F
   return starts.some((span) => valuesIn(values, span).some((value) => value.kind === "date" && sameValue(date, value)));
 };
 
-/** 主語と区切りの後ろの期間（保証期間は、お買い上げ日から24か月です）。 */
-const subjectFact = (source: string, value: FactValue, values: readonly FactValue[], words: TermValueWords): Fact | undefined => {
+/** 主語と区切りの後ろの期間（保証期間は、お買い上げ日から24か月です）。restatedOnly: 何に使ったかを言う句の付いた主語だけ。 */
+const subjectFact = (source: string, value: FactValue, values: readonly FactValue[], words: TermValueWords, restatedOnly = false): Fact | undefined => {
   const subject = subjectOf(source, clauseStartOf(source, value.start), value.start, words);
-  if (subject === undefined) return undefined;
+  if (subject === undefined || (restatedOnly && !subject.restated)) return undefined;
   const before = startBeforeValue(source, { start: subject.restStart, end: value.start }, values, words);
   if (before === undefined) return undefined;
   const after = startAfterValue(source, value.end, values, words);
@@ -226,11 +259,59 @@ const unitNamedFact = (source: string, value: FactValue, words: TermValueWords):
 
 const DURATION_UNITS = new Set(["day", "week", "month", "year"]);
 
-/** 語彙表の項目を主語にした文の、期間の値。values は文書の中の順の値（日付を含む）。 */
+/** 型の前と後ろの字（を*として の を と として）。 */
+const frameParts = (frame: string): readonly [string, string] | undefined => {
+  const at = frame.indexOf("*");
+  return at <= 0 || at === frame.length - 1 ? undefined : [frame.slice(0, at), frame.slice(at + 1)];
+};
+
+/** 型の前の句（扶養控除は、）が、値も条件の語も含まないか。条件の句（登録された場合、）の後ろの値は、その場合の値。 */
+const isPlainLead = (source: string, lead: Span, values: readonly FactValue[], words: TermValueWords): boolean => {
+  const written = folded(source.slice(lead.start, lead.end));
+  return valuesIn(values, lead).length === 0 && !(words.conditions ?? []).some((word) => written.includes(folded(word)));
+};
+
+/** 型の名前（扶養親族の数を2人として の 扶養親族の数）。名前は読点の後ろから。 */
+const framedFact = (
+  source: string,
+  value: FactValue,
+  values: readonly FactValue[],
+  words: TermValueWords,
+  [open, close]: readonly [string, string],
+): Fact | undefined => {
+  const from = clauseStartOf(source, value.start);
+  const labelEnd = value.start - open.length;
+  if (labelEnd <= from || source.slice(labelEnd, value.start) !== open || !source.startsWith(close, value.end)) return undefined;
+  const head = source.slice(from, labelEnd);
+  const comma = [...head.matchAll(CLAUSE_COMMAS)].at(-1)?.index ?? -1;
+  const label = withoutEdgeMarks(head.slice(comma + 1));
+  const key = termKeyOf(label, words);
+  if (key === undefined || !isPlainLead(source, { start: from, end: from + Math.max(comma, 0) }, values, words)) return undefined;
+  return { label, key, value };
+};
+
+/** 名前と値を囲む型の値（扶養控除は、扶養親族の数を2人として計算しています）。 */
+const frameFact = (source: string, value: FactValue, values: readonly FactValue[], words: TermValueWords): Fact | undefined =>
+  (words.frames ?? [])
+    .flatMap((frame) => {
+      const parts = frameParts(frame);
+      const fact = parts === undefined ? undefined : framedFact(source, value, values, words, parts);
+      return fact === undefined ? [] : [fact];
+    })
+    .at(0);
+
+const durationFact = (source: string, value: FactValue, values: readonly FactValue[], words: TermValueWords): Fact | undefined =>
+  bracketFact(source, value, words) ?? subjectFact(source, value, values, words) ?? unitNamedFact(source, value, words);
+
+/**
+ * 語彙表の項目を主語にした文の、期間の値。期間でない数は、何に使ったかを言う句の付いた主語（the number of dependants used for the
+ * allowance is 2）か、名前と値を囲む型（扶養親族の数を2人として）のときだけ。values は文書の中の順の値（日付を含む）。
+ */
 export const termValues = (source: string, values: readonly FactValue[], words: TermValueWords): Fact[] =>
   values
-    .filter((value) => value.kind === "quantity" && DURATION_UNITS.has(value.unit))
+    .filter((value) => value.kind === "quantity")
     .flatMap((value) => {
-      const fact = bracketFact(source, value, words) ?? subjectFact(source, value, values, words) ?? unitNamedFact(source, value, words);
+      const read = DURATION_UNITS.has(value.unit) ? durationFact(source, value, values, words) : subjectFact(source, value, values, words, true);
+      const fact = read ?? frameFact(source, value, values, words);
       return fact === undefined ? [] : [fact];
     });

package/src/grade/baseline.ts

@@ -60,13 +60,22 @@ type Pair = { readonly before: GradeResult; readonly after: GradeResult };
 
 const countIn = (result: GradeResult, rule: string): number => result.findings.filter((finding) => finding.rule === rule).length;
 
-const movementsOf = (pairs: readonly Pair[], rubricRules: ReadonlySet<string>): RuleMovement[] =>
+/** The rules the rubric names for one output: with rubric tasks, its task's rules over the top level's. */
+export type RubricRulesOf = (result: GradeResult) => ReadonlySet<string>;
+
+/** A rule's movement, and the outputs it rose in whose own rubric names it: only those are a regression. */
+type Moved = { readonly movement: RuleMovement; readonly regressedIn: readonly string[] };
+
+const movementsOf = (pairs: readonly Pair[], rubricRulesOf: RubricRulesOf): Moved[] =>
   rateRows([pairs.map((pair) => pair.before), pairs.map((pair) => pair.after)]).flatMap(({ rule, unit, rates: [before = 0, after = 0] }) => {
     const inUnit = pairs.filter((pair) => pair.after.size.unit === unit);
-    const increasedIn = inUnit.filter((pair) => countIn(pair.after, rule) > countIn(pair.before, rule)).map((pair) => resultName(pair.after));
+    const increased = inUnit.filter((pair) => countIn(pair.after, rule) > countIn(pair.before, rule));
+    const increasedIn = increased.map((pair) => resultName(pair.after));
     const decreasedIn = inUnit.filter((pair) => countIn(pair.after, rule) < countIn(pair.before, rule)).map((pair) => resultName(pair.after));
     if (increasedIn.length === 0 && decreasedIn.length === 0 && before === after) return [];
-    return [{ rule, unit, before, after, increasedIn, decreasedIn, inRubric: rubricRules.has(rule) }];
+    const graded = (pair: Pair): boolean => rubricRulesOf(pair.after).has(rule);
+    const regressedIn = increased.filter(graded).map((pair) => resultName(pair.after));
+    return [{ movement: { rule, unit, before, after, increasedIn, decreasedIn, inRubric: inUnit.some(graded) }, regressedIn }];
   });
 
 const factKey = (fact: GradeFact): string => `${fact.kind}\n${fact.key}`;
@@ -100,11 +109,9 @@ const penaltyOf = (results: readonly GradeResult[]): number => results.reduce((s
 
 const scored = (pairs: readonly Pair[]): boolean => pairs.some((pair) => pair.after.score !== undefined);
 
-const regressionsOf = (newlyFailed: readonly string[], movements: readonly RuleMovement[], penalty: Comparison["penalty"]): string[] => [
+const regressionsOf = (newlyFailed: readonly string[], moved: readonly Moved[], penalty: Comparison["penalty"]): string[] => [
   ...newlyFailed.map((id) => `${id}: passed, now fails`),
-  ...movements
-    .filter((movement) => movement.inRubric && movement.increasedIn.length > 0)
-    .map((movement) => `rules.${movement.rule}: more findings in ${movement.increasedIn.join(", ")}`),
+  ...moved.filter((entry) => entry.regressedIn.length > 0).map((entry) => `rules.${entry.movement.rule}: more findings in ${entry.regressedIn.join(", ")}`),
   ...(penalty !== undefined && penalty.after > penalty.before ? [`score.penalty ${String(penalty.before)} → ${String(penalty.after)}`] : []),
 ];
 
@@ -112,9 +119,10 @@ const pairRead = (pair: Pair): boolean => sameReading([pair.before, pair.after])
 
 /**
  * `after` compared with `before`, output by output: an output is paired with the earlier one of its id and variant.
- * `rubricRules`: the rules the rubric names, whose increase is a regression.
+ * `rubricRules`: the rules the rubric names, whose increase is a regression; per output when the rubric has tasks.
  */
-export const compareRuns = (before: readonly GradeResult[], after: readonly GradeResult[], rubricRules: ReadonlySet<string>): Comparison => {
+export const compareRuns = (before: readonly GradeResult[], after: readonly GradeResult[], rubricRules: ReadonlySet<string> | RubricRulesOf): Comparison => {
+  const rubricRulesOf: RubricRulesOf = typeof rubricRules === "function" ? rubricRules : () => rubricRules;
   const earlier = new Map(before.map((result) => [resultKey(result), result]));
   const keys = new Set(after.map(resultKey));
   const matched = after.flatMap((result) => {
@@ -122,7 +130,7 @@ export const compareRuns = (before: readonly GradeResult[], after: readonly Grad
     return match === undefined ? [] : [{ before: match, after: result }];
   });
   const pairs = matched.filter(pairRead);
-  const rules = movementsOf(pairs, rubricRules);
+  const moved = movementsOf(pairs, rubricRulesOf);
   const newlyFailed = pairs.filter((pair) => pair.before.pass && !pair.after.pass).map((pair) => resultName(pair.after));
   const penalty = scored(pairs) ? { before: penaltyOf(pairs.map((pair) => pair.before)), after: penaltyOf(pairs.map((pair) => pair.after)) } : undefined;
   return {
@@ -130,11 +138,11 @@ export const compareRuns = (before: readonly GradeResult[], after: readonly Grad
     onlyBefore: before.filter((result) => !keys.has(resultKey(result))).map(resultName),
     onlyAfter: after.filter((result) => !earlier.has(resultKey(result))).map(resultName),
     readOtherwise: matched.filter((pair) => !pairRead(pair)).map((pair) => resultName(pair.after)),
-    rules,
+    rules: moved.map((entry) => entry.movement),
     newlyFailed,
     newlyPassed: pairs.filter((pair) => !pair.before.pass && pair.after.pass).map((pair) => resultName(pair.after)),
     items: pairs.map(itemChange).filter((change) => change.dropped.length + change.added.length + change.citations.length > 0),
     ...(penalty === undefined ? {} : { penalty }),
-    regressions: regressionsOf(newlyFailed, rules, penalty),
+    regressions: regressionsOf(newlyFailed, moved, penalty),
   };
 };

package/src/grade/expect-read.ts

@@ -0,0 +1,65 @@
+import { documentLanguage } from "../check-source.ts";
+import { factsOf } from "../commands/compare.ts";
+import { documentFromSource } from "../commands/read-document.ts";
+import type { Compared } from "../compare/outcome.ts";
+import { resolveGenre } from "../resolve-genre.ts";
+import { OUTPUT_PATH, type ItemReading } from "./checks.ts";
+import { EXPECT_LISTS, entryPath, expectAgainst, factOfEntry, type GradeExpect, type GradeExpectResult, type ReadEntry } from "./expect.ts";
+import type { GradeItem, ItemProblem } from "./item.ts";
+
+// An item's `expect` entries read as compare reads a document, in the output's language and genre, so an entry and
+// the output spell one fact alike.
+
+const ENTRY_PATH = "expect.md";
+
+type EntryRead = { readonly entry: ReadEntry } | { readonly problem: Omit<ItemProblem, "line"> };
+
+const readEntry = async (list: ReadEntry["list"], index: number, entry: string, reading: ItemReading & { readonly language: string }): Promise<EntryRead> => {
+  const prose = await documentFromSource(ENTRY_PATH, entry, { language: reading.language, genre: reading.genre }, reading.config, true);
+  const facts = factsOf(ENTRY_PATH, prose, reading.config.names ?? []);
+  const found = factOfEntry(entry, facts.extraction.atoms);
+  if ("unread" in found)
+    return { problem: { kind: found.unread === "no-fact" ? "expect-no-fact" : "expect-several-facts", detail: `${entryPath(list, index)} ${entry}` } };
+  return { entry: { list, index, entry, read: { path: ENTRY_PATH, extraction: { ...facts.extraction, atoms: [found.fact] } } } };
+};
+
+const readEntries = (expect: GradeExpect, reading: ItemReading & { readonly language: string }): Promise<EntryRead[]> =>
+  Promise.all(EXPECT_LISTS.flatMap((list) => expect[list].map((entry, index) => readEntry(list, index, entry, reading))));
+
+/** The output's own facts, read as `chaff compare` reads the document after. */
+const outputFacts = async (output: string, reading: ItemReading & { readonly language: string }): Promise<Compared> => {
+  const prose = await documentFromSource(OUTPUT_PATH, output, { language: reading.language, genre: reading.genre }, reading.config, true);
+  return factsOf(OUTPUT_PATH, prose, reading.config.names ?? []);
+};
+
+/** The language and genre the output is graded in, as checkSource chooses them. */
+const itemReading = (item: GradeItem, setup: { readonly config: ItemReading["config"]; readonly genre?: string | undefined }) => ({
+  config: setup.config,
+  language: item.language ?? documentLanguage(OUTPUT_PATH, item.output, setup.config),
+  genre: resolveGenre(OUTPUT_PATH, item.output, setup.config, item.genre ?? setup.genre).genre,
+});
+
+/** Each entry chaff cannot read as exactly one fact, on the item's line: the run stops before grading (exit 2). */
+export const expectProblems = async (
+  item: GradeItem,
+  line: number,
+  setup: { readonly config: ItemReading["config"]; readonly genre?: string | undefined },
+): Promise<ItemProblem[]> => {
+  if (item.expect === undefined) return [];
+  const read = await readEntries(item.expect, itemReading(item, setup));
+  return read.flatMap((entry) => ("problem" in entry ? [{ ...entry.problem, line }] : []));
+};
+
+/**
+ * The output against the item's expect, read in the language and genre it was graded in. Throws for an entry that is
+ * not one fact: `chaff grade` refuses such an item before grading (expectProblems), so none reaches here.
+ */
+export const expectOfItem = async (item: GradeItem, reading: ItemReading & { readonly language: string }): Promise<GradeExpectResult | undefined> => {
+  if (item.expect === undefined) return undefined;
+  const read = await readEntries(item.expect, reading);
+  const entries = read.flatMap((entry) => {
+    if ("problem" in entry) throw new Error(`${item.id}: ${entry.problem.detail ?? ""} is not one fact`);
+    return [entry.entry];
+  });
+  return expectAgainst(entries, await outputFacts(item.output, reading));
+};