chaffjs 0.33.0 → 0.35.0

package/src/structure/closing-balance.ts

@@ -11,7 +11,11 @@ import { amountOf, isExact, shown, type LabelledLine, type NetAmount, type NetCe
 export const BALANCE_ROLES = ["opening", "inflow", "outflow", "closing"] as const;
 export type BalanceRole = (typeof BALANCE_ROLES)[number];
 
-export type BalanceWords = Pick<NetWords, "magnitudes" | "percentUnits"> & { readonly labels: Readonly<Record<BalanceRole, readonly string[]>> };
+export type BalanceWords = Pick<NetWords, "magnitudes" | "percentUnits"> & {
+  readonly labels: Readonly<Record<BalanceRole, readonly string[]>>;
+  /** Words that make a label's note the date the balance is taken on (時点, as of): such a note is not a unit. */
+  readonly asOf?: readonly string[] | undefined;
+};
 
 export type BalanceAmount = NetAmount & { readonly role: BalanceRole };
 
@@ -54,12 +58,46 @@ export const closingMismatch = (amounts: readonly BalanceAmount[], words: Balanc
   return { offset: closing.start, values: { written: closing.written, expected: shown(expected, closing, decimals) } };
 };
 
-const labelledCells = (labels: readonly NetCell[], values: readonly NetCell[], words: BalanceWords): BalanceAmount[] =>
+const DIGIT = /\d/u;
+
+/** A note naming the date a balance is taken on (（2026年6月30日時点）, (as of June 30, 2026)): a date, not a unit. */
+export const isDatedNote = (note: string, asOf: readonly string[]): boolean => {
+  const key = keyOf(note);
+  return DIGIT.test(key) && asOf.some((word) => key.includes(keyOf(word)));
+};
+
+const CURRENCY_CODE = /\b[A-Z]{3}\b/u;
+
+/** A note that names a scale or a currency besides the date ((thousand yen, as of June 30, 2026)) still names a unit. */
+const namesUnitToo = (note: string, words: BalanceWords): boolean =>
+  CURRENCY_CODE.test(note.normalize("NFKC")) || words.magnitudes.some((word) => keyOf(note).includes(keyOf(word)));
+
+/** The note of a label that may give its amount a unit: a note that only dates it gives none, so dated and undated rows compare. */
+const unitNoteOf = (label: string, words: BalanceWords): string => {
+  const note = noteOf(label);
+  return isDatedNote(note, words.asOf ?? []) && !namesUnitToo(note, words) ? "" : note;
+};
+
+/** A column heading that is a word with no digit or bracket (ポイント, Points): the unit of the bare numbers under it. */
+const UNIT_HEADING = /^[^\d()[\]（）]+$/u;
+const BARE_MARKS = "||";
+
+/**
+ * A bare number under a heading naming its unit compares with the cells that write the unit out (14,310 under ポイント,
+ * against 4,960ポイント). Its marks stay empty, so it is still read as possibly rounded.
+ */
+export const withHeadingUnit = (amount: NetAmount, heading: string | undefined): NetAmount => {
+  const unit = keyOf(heading ?? "");
+  if (amount.prefix + amount.suffix !== "" || !UNIT_HEADING.test(unit)) return amount;
+  return { ...amount, unit: `|${unit}|${amount.unit.slice(BARE_MARKS.length)}` };
+};
+
+const labelledCells = (labels: readonly NetCell[], values: readonly NetCell[], words: BalanceWords, heading?: string): BalanceAmount[] =>
   labels.flatMap((label, column) => {
     const role = balanceRoleOf(label.text, words);
     const value = values[column];
-    const amount = role === undefined || value === undefined ? undefined : amountOf(value.text, value.start, noteOf(label.text), words);
-    return role === undefined || amount === undefined ? [] : [{ ...amount, role }];
+    const amount = role === undefined || value === undefined ? undefined : amountOf(value.text, value.start, unitNoteOf(label.text, words), words);
+    return role === undefined || amount === undefined ? [] : [{ ...withHeadingUnit(amount, heading), role }];
   });
 
 const issuesOf = (scopes: readonly (readonly BalanceAmount[])[], words: BalanceWords): NetIssue[] =>
@@ -75,14 +113,14 @@ const byColumns = (header: readonly NetCell[], rows: readonly (readonly NetCell[
     words,
   );
 
-/** A table whose rows are labelled in their first cell: each column after the labels is one scope. */
-const byRows = (rows: readonly (readonly NetCell[])[], words: BalanceWords): NetIssue[] => {
+/** A table whose rows are labelled in their first cell: each column after the labels is one scope, under its heading. */
+const byRows = (header: readonly NetCell[], rows: readonly (readonly NetCell[])[], words: BalanceWords): NetIssue[] => {
   const labelled = rows.filter((row) => row[0] !== undefined && balanceRoleOf(row[0].text, words) !== undefined);
   const width = labelled[0]?.length ?? 0;
   if (labelled.length === 0 || labelled.some((row) => row.length !== width)) return [];
   const columns = Array.from({ length: width - 1 }, (_, index) => index + 1);
   return issuesOf(
-    columns.map((column) => labelled.flatMap((row) => labelledCells(row.slice(0, 1), row.slice(column, column + 1), words))),
+    columns.map((column) => labelled.flatMap((row) => labelledCells(row.slice(0, 1), row.slice(column, column + 1), words, header[column]?.text))),
     words,
   );
 };
@@ -92,7 +130,7 @@ const byRows = (rows: readonly (readonly NetCell[])[], words: BalanceWords): Net
  * four totals in its header or its first column, so it gives no scope; running-balance-mismatch reads it row by row.
  */
 export const tableClosingMismatches = (header: readonly NetCell[], rows: readonly (readonly NetCell[])[], words: BalanceWords): NetIssue[] => {
-  const issues = [...byColumns(header, rows, words), ...byRows(rows, words)];
+  const issues = [...byColumns(header, rows, words), ...byRows(header, rows, words)];
   return issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
 };
 

package/src/structure/definition-use.ts

@@ -200,6 +200,27 @@ const echoesLongName = (texts: readonly BodyText[], defined: DefinedTerm, offset
   return name.endsWith(defined.term) && sharedTail(name, written) >= defined.term.length + MIN_ECHO;
 };
 
+/** What may follow a word inside a name up to a definition's bracket: capitalised words (Services Agreement), or kanji and katakana (本サービス利用契約). */
+const NAME_RUN = /^(?:['’]?s)?(?:\s+\p{Lu}[\p{L}\p{N}&.'’-]*)*$|^[\p{Script=Han}\p{Script=Katakana}ー・･]*$/u;
+
+/**
+ * 別の語を定義する括弧の前の名前の中の現れ（This Services Agreement (this "Agreement") の Services、
+ * 本サービス利用契約（以下「本契約」という。）の本サービス）。文書が自分に付けた名前で、後で定義する語の使用ではない。
+ */
+const insideDefiningName = (texts: readonly BodyText[], inline: readonly DefinedTerm[], defined: DefinedTerm, offset: number): boolean => {
+  const body = sentenceAt(texts, offset);
+  if (body === undefined) return false;
+  const from = offset + defined.term.length;
+  const bodyEnd = body.start + body.text.length;
+  return inline.some(
+    (other) =>
+      other.term !== defined.term &&
+      other.span.start >= from &&
+      other.span.start <= bodyEnd &&
+      NAME_RUN.test(nameBefore(body.text.slice(from - body.start, other.span.start - body.start))),
+  );
+};
+
 const CAPITAL_OR_NON_LATIN = /\p{Lu}|[^\p{Script=Latin}\p{N}\s\p{P}]/u;
 
 /**
@@ -226,6 +247,7 @@ export const usesBeforeDefinition = (
   groupsOf(terms)
     .filter((group) => group.first.inline && isDistinctive(group.first.term))
     .flatMap(({ first: defined, spans }) => {
+      const inline = terms.filter((term) => term.inline);
       const defining = sentenceAt(texts, defined.span.start)?.start ?? defined.span.start;
       const uses = usesOf(defined.term, texts, spans, "exact", defined.bare === true ? mentioned : NEVER_MENTIONED);
       const first = uses.find(
@@ -234,7 +256,8 @@ export const usesBeforeDefinition = (
           !isTitle(offset) &&
           !continuesInHan(texts, defined.term, offset) &&
           !insideKatakanaName(texts, defined.term, offset) &&
-          !echoesLongName(texts, defined, offset),
+          !echoesLongName(texts, defined, offset) &&
+          !insideDefiningName(texts, inline, defined, offset),
       );
       return first !== undefined && first < defining ? [{ term: defined, offset: first }] : [];
     });

package/src/structure/document-context.ts

@@ -0,0 +1,46 @@
+import { linesOf } from "./lines.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { leadingText } from "./total.ts";
+
+/**
+ * Whether a document says what kind of document it is with one of the words: its title contains one (会議室ご利用御見積書,
+ * Meeting Room Quote), or a field's label is one (見積番号：MR-0733, Quote number: Q-1). The title is the first line with
+ * text after any front matter, and the first heading; a table row is neither. A label only starting with a word does not
+ * count (Withholding tax: on an invoice), nor does a word in a sentence. Width and case are ignored. Pure.
+ */
+
+const LABEL_SEPARATOR = /[:：|]/u;
+const HEADING = /^[ \t]*#+[ \t]*/u;
+const TABLE_ROW = /^[ \t]*\|/u;
+const FRONT_MATTER_FENCE = /^---[ \t]*$/u;
+
+const keyOf = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
+
+/** The lines after a front matter block (--- … --- at the very top); all of them when there is none. */
+const afterFrontMatter = (lines: readonly string[]): readonly string[] => {
+  if (!FRONT_MATTER_FENCE.test(lines[0] ?? "")) return lines;
+  const close = lines.findIndex((line, index) => index > 0 && FRONT_MATTER_FENCE.test(line));
+  return close === -1 ? lines : lines.slice(close + 1);
+};
+
+const titlesOf = (lines: readonly string[]): string[] => {
+  const first = lines.find((line) => line.trim().length > 0 && !TABLE_ROW.test(line));
+  const heading = lines.find((line) => HEADING.test(line));
+  return [first, heading].flatMap((line) => (line === undefined ? [] : [keyOf(line.replace(HEADING, ""))]));
+};
+
+const labelOf = (line: string): string | undefined => {
+  const lead = leadingText(line);
+  const separator = LABEL_SEPARATOR.exec(lead);
+  return separator === null ? undefined : keyOf(withoutEdgeMarks(lead.slice(0, separator.index)));
+};
+
+export const namesDocumentKind = (source: string, words: readonly string[]): boolean => {
+  const keys = words.map(keyOf);
+  const lines = afterFrontMatter(linesOf(source).map((line) => line.text));
+  if (titlesOf(lines).some((title) => keys.some((key) => title.includes(key)))) return true;
+  return lines.some((line) => {
+    const label = labelOf(line);
+    return label !== undefined && keys.includes(label);
+  });
+};

package/src/structure/fenced-lines.ts

@@ -0,0 +1,28 @@
+import { codeFences } from "../detectors/code-fences.ts";
+
+const FENCE_MARK = /`{3}|~{3}/u;
+
+const NONE: ReadonlySet<number> = new Set();
+
+/** The index of the line holding an offset of the joined lines. */
+const lineIndexAt = (starts: readonly number[], offset: number): number => starts.findLastIndex((start) => start <= offset);
+
+/**
+ * The indexes of the lines of fenced code blocks (``` or ~~~), the fences included. A table or a list written in one is an
+ * example, not the document's own values. The blocks are the ones the Markdown parser reads (code-fences.ts): a fence in
+ * a list item is one, a line indented as code or a fence in a quotation is not, and an unclosed fence runs to the end.
+ */
+export const fencedLineIndexes = (texts: readonly string[]): ReadonlySet<number> => {
+  if (!texts.some((text) => FENCE_MARK.test(text))) return NONE;
+  const starts: number[] = [];
+  texts.reduce((start, text) => {
+    starts.push(start);
+    return start + text.length + 1;
+  }, 0);
+  const fenced = new Set<number>();
+  codeFences(texts.join("\n")).forEach((fence) => {
+    const last = lineIndexAt(starts, Math.max(fence.start, fence.end - 1));
+    for (let index = lineIndexAt(starts, fence.start); index <= last; index += 1) fenced.add(index);
+  });
+  return fenced;
+};

package/src/structure/html-text-blocks.ts

@@ -0,0 +1,45 @@
+import { readMarkdown } from "../markdown-read.ts";
+import { spanOf, type MarkdownNode } from "../markdown-node.ts";
+import type { Span } from "../plugin.ts";
+
+const COMMENT = /<!--[\s\S]*?(?:-->|$)/gu;
+const INLINE_CONTAINERS = new Set(["paragraph", "heading", "tableCell"]);
+const ENTITY = /&(?:#\d+|#x[\da-f]+|[a-z]+\d*);/giu;
+
+type TagScan = { readonly kept: string[]; inTag: boolean; quote: string | undefined };
+
+/** Reads one character of HTML: text outside a tag is kept. A quoted attribute may hold `>` (`<div title=">">`). */
+const scanned = (scan: TagScan, char: string): TagScan => {
+  if (!scan.inTag) {
+    if (char === "<") scan.inTag = true;
+    else scan.kept.push(char);
+  } else if (scan.quote !== undefined) {
+    if (char === scan.quote) scan.quote = undefined;
+  } else if (char === '"' || char === "'") scan.quote = char;
+  else if (char === ">") scan.inTag = false;
+  return scan;
+};
+
+const withoutTags = (html: string): string => [...html].reduce<TagScan>(scanned, { kept: [], inTag: false, quote: undefined }).kept.join("");
+
+/** What an HTML block shows the reader: its text without tags, comments and character references such as `&nbsp;`. */
+const showsText = (html: string): boolean => withoutTags(html.replace(COMMENT, "")).replace(ENTITY, "").trim() !== "";
+
+/**
+ * Markdown's HTML blocks that show text. CommonMark runs a block that starts with a tag alone on its line (`<br/>`) to
+ * the next blank line, so a `第11条` written right under it is raw HTML: the reader sees it, chaff's structure does not.
+ * Only blocks are returned; an inline tag inside a paragraph (`text<br/>`) leaves the text beside it readable.
+ */
+export const htmlTextBlocks = (source: string): Span[] => {
+  if (!source.includes("<")) return [];
+  const blocks: Span[] = [];
+  const visit = (node: MarkdownNode, inParagraph: boolean): void => {
+    if (node.type === "html" && !inParagraph && showsText(node.value ?? "")) {
+      const span = spanOf(node);
+      if (span !== undefined) blocks.push(span);
+    }
+    (node.children ?? []).forEach((child) => visit(child, inParagraph || INLINE_CONTAINERS.has(node.type)));
+  };
+  visit(readMarkdown(source).root, false);
+  return blocks.toSorted((left, right) => left.start - right.start);
+};

package/src/structure/issues.ts

@@ -1,6 +1,10 @@
 import type { StructureNode } from "../plugin.ts";
+import { writtenReading } from "./written-resolve.ts";
+import { namedTargets, pointsToNamedSection } from "./section-names.ts";
 import { listedTags } from "./listed-tags.ts";
 import { namesAbsentUnit } from "./unit-word.ts";
+import { isListedParagraph, listedParagraphsByArticle } from "./listed-paragraph.ts";
+import { referencesInCitedDocuments } from "./cited-document-section.ts";
 
 // 木だけで決まる誤り。参照先が無い、番号が飛ぶ・重なる、同じ語を二度定義する。
 // 意味の食い違いは判定しない。書いてあることから機械で決まるものだけを出す。
@@ -111,7 +115,7 @@ const numbering = (node: StructureNode): unknown => node.attrs["numbering"];
  * 参照の番地が木に無い。他の文書の名前が付いた参照（民法第709条、Section 9 of the Master Agreement）は引かない。
  * 条を 1 つも持たない文書も見ない。他の文書を指しているだけかもしれない。
  */
-export const danglingReferences = (tree: StructureNode, source: string): StructureIssue[] => {
+export const danglingReferences = (tree: StructureNode, source: string, nameNouns: readonly string[] = []): StructureIssue[] => {
   const nodes = inDocumentOrder(tree);
   // 参照は条を指す。条を一つも持たない文書（契約書に付ける承諾書のひな形など）の「契約書第6条」は、別の文書の条。
   if (!nodes.some((node) => node.kind === "article")) return [];
@@ -127,10 +131,21 @@ export const danglingReferences = (tree: StructureNode, source: string): Structu
   const articleLabels = nodes.filter((node) => node.kind === "article").map((node) => textOf(node, "label"));
   const chapters = chaptersOf(nodes);
   const elsewhere = elsewhereReferences(nodes, source);
-  return nodes
-    .filter((node) => node.kind === "reference" && !citesOther(node) && !otherNumbering(node))
+  const quoted = referencesInCitedDocuments(tree);
+  const references = nodes.filter((node) => node.kind === "reference");
+  const named = namedTargets(references, source, nameNouns);
+  const unresolved = references
+    .filter((node) => !citesOther(node) && !otherNumbering(node) && !pointsToNamedSection(node, named))
     .filter((node) => !namesAbsentUnit(node, articleLabels) && !elsewhere.has(node))
-    .filter((node) => !resolves(node, addresses, chapters))
+    .filter((node) => !quoted.has(node) && !resolves(node, addresses, chapters));
+  // 規程は条の下の項を箇条書き（「1. 」「２．」）で書くことがあり、木はそれを項として読まない。条の本文は、要るときに一度だけ読む。
+  const listed = unresolved.length === 0 ? new Map() : listedParagraphsByArticle(nodes, source);
+  // 平文の契約は見出しを「9. Indemnification.」と本文の形で書き、木はそれを番地にしない。残った参照があるときだけ読む。
+  const written = unresolved.length === 0 ? undefined : writtenReading(nodes, source);
+  const writtenAddresses = new Set(written?.addresses);
+  return unresolved
+    .filter((node) => !isListedParagraph(textOf(node, "target"), listed))
+    .filter((node) => !writtenAddresses.has(textOf(node, "target")) && written?.subdivision(node) !== true)
     .map((node) => ({ offset: node.span.start, values: { label: textOf(node, "label"), target: textOf(node, "target") } }));
 };
 

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

@@ -1,8 +1,11 @@
+import { namesDocumentKind } from "./document-context.ts";
 import type { DatedPoint } from "./due-date.ts";
 import type { StructureIssue } from "./issues.ts";
 import type { Line } from "./lines.ts";
 import { labelPairsOf, pointsOutOfOrder, type OrderLabel, type PairWords, type PointOf } from "./labelled-order.ts";
 import { TABLE_ROW } from "./runs.ts";
+import type { VersionWords } from "./versioned-label.ts";
+import { isSignedDateLine } from "./signed-date-line.ts";
 import { statedPeriod, type DateMention, type PeriodWords } from "./stated-period.ts";
 
 /**
@@ -10,11 +13,13 @@ import { statedPeriod, type DateMention, type PeriodWords } from "./stated-perio
  * earlier-date word and one starting with a later-date word, each with one full date on it. A later date before the
  * first earlier date, and written near it, is out of order. A line with a passed word (期限切れ, overdue) reports on a
  * date rather than setting one and is not read. A span word (対象期間, Reporting period) labels a period, and the
- * period's end is its date. Pure.
+ * period's end is its date, or its start for a span word in fromStart. Pure.
  */
 export type DateOrderWords = PairWords & {
   /** The words whose line states a period rather than one date (labels), with the range signs and names to read it. */
   readonly spans?: PeriodWords | undefined;
+  /** The span words whose period's start is the date: the later date may fall anywhere in the period (a pay date in its pay period). */
+  readonly fromStart?: readonly string[] | undefined;
 };
 
 /** A date from the tree; end is where its text ends, needed only to read a period. */
@@ -30,12 +35,14 @@ const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
 const mentionsOf = (dates: readonly OrderDate[]): DateMention[] => dates.flatMap((date) => (date.end === undefined ? [] : [{ ...date, end: date.end }]));
 
 /**
- * The end of the period a span word's line states (対象期間：2026年4月1日〜9月30日 ends 2026-09-30), with its year.
- * A period without a year, or a line that states no period, gives undefined. tableOf gives the table the line is a row of
- * (| 対象期間 | 2026年4月1日〜9月30日 |), read when the row is the table's only row labelled with any span word: a table with
- * both Reporting period and Period covered rows lists periods. A row's label cell is the span word itself, so all of them are passed.
+ * The start or the end of the period a span word's line states (対象期間：2026年4月1日〜9月30日 starts 2026-04-01 and
+ * ends 2026-09-30), with its year. A period without a year, or a line that states no period, gives undefined. tableOf gives
+ * the table the line is a row of (| 対象期間 | 2026年4月1日〜9月30日 |), read when the row is the table's only row labelled
+ * with any span word: a table with both Reporting period and Period covered rows lists periods. A row's label cell is the
+ * span word itself, so all of them are passed.
  */
-export const periodEndOf = (
+const periodBoundOf = (
+  bound: "start" | "end",
   line: Line,
   label: string,
   dates: readonly OrderDate[],
@@ -44,24 +51,54 @@ export const periodEndOf = (
 ): DatedPoint | undefined => {
   const labels = TABLE_ROW.test(line.text) ? spans.labels : [label];
   const period = statedPeriod(line.text, line.start, mentionsOf(dates), { ...spans, labels }, tableOf);
-  return period === undefined || !FULL_DATE.test(period.end) ? undefined : { offset: line.start, value: period.end };
+  return period === undefined || !FULL_DATE.test(period[bound]) ? undefined : { offset: line.start, value: period[bound] };
 };
 
-const oneDateOf = (line: Line, dates: readonly OrderDate[]): DatedPoint | undefined => {
+/** The end of the period a span word's line states. */
+export const periodEndOf = (
+  line: Line,
+  label: string,
+  dates: readonly OrderDate[],
+  spans: PeriodWords,
+  tableOf?: () => readonly string[],
+): DatedPoint | undefined => periodBoundOf("end", line, label, dates, spans, tableOf);
+
+/** The start of the period a span word's line states. */
+export const periodStartOf = (
+  line: Line,
+  label: string,
+  dates: readonly OrderDate[],
+  spans: PeriodWords,
+  tableOf?: () => readonly string[],
+): DatedPoint | undefined => periodBoundOf("start", line, label, dates, spans, tableOf);
+
+const oneDateOf = (line: Line, dates: readonly OrderDate[]): OrderDate | undefined => {
   const end = line.start + line.text.length;
   const onLine = dates.filter((date) => date.offset >= line.start && date.offset <= end && FULL_DATE.test(date.value));
   return onLine.length === 1 ? onLine[0] : undefined;
 };
 
+/** The one date on a signature line (2026年4月12日 会計監査 戸川 隆): the line holds that date, the role and a name, nothing else. */
+const signedDateOf = (line: Line, role: string, dates: readonly OrderDate[]): DatedPoint | undefined => {
+  const date = oneDateOf(line, dates);
+  if (date?.end === undefined) return undefined;
+  const span = { start: date.offset - line.start, end: date.end - line.start };
+  return isSignedDateLine(line.text, role, span) ? date : undefined;
+};
+
 const dateOf =
-  (dates: readonly OrderDate[], spans: PeriodWords | undefined): PointOf =>
+  (dates: readonly OrderDate[], spans: PeriodWords | undefined, fromStart: readonly string[], signers: readonly string[]): PointOf =>
   (line, label, tableOf) => {
+    if (signers.includes(label)) {
+      const date = signedDateOf(line, label, dates);
+      return date === undefined ? undefined : { point: date, span: false };
+    }
     if (spans === undefined || !spans.labels.includes(label)) {
       const date = oneDateOf(line, dates);
       return date === undefined ? undefined : { point: date, span: false };
     }
-    const end = periodEndOf(line, label, dates, spans, tableOf);
-    return end === undefined ? undefined : { point: end, span: true };
+    const bound = fromStart.includes(label) ? periodStartOf(line, label, dates, spans, tableOf) : periodEndOf(line, label, dates, spans, tableOf);
+    return bound === undefined ? undefined : { point: bound, span: true };
   };
 
 /**
@@ -70,18 +107,61 @@ const dateOf =
  * record's. A later date written once (an issue date below the records) belongs to the whole document and keeps the first.
  */
 export const datesOutOfOrder = (source: string, dates: readonly OrderDate[], words: DateOrderWords): OutOfOrder[] =>
-  pointsOutOfOrder(source, words, dateOf(dates, words.spans)).map(({ earlier, later }) => ({
+  pointsOutOfOrder(source, words, dateOf(dates, words.spans, words.fromStart ?? [], words.signers ?? [])).map(({ earlier, later }) => ({
     earlier: { label: earlier.label, date: earlier.point, line: earlier.line, span: earlier.span },
     later: { label: later.label, date: later.point, line: later.line, span: later.span },
   }));
 
-/** An out-of-order pair; period is set when the earlier date is the end of a stated period. */
-export type PairedIssue = StructureIssue & { readonly period: boolean };
+/** An out-of-order pair; period is set when the earlier date is a stated period's end, or its start when fromStart is set. */
+export type PairedIssue = StructureIssue & { readonly period: boolean; readonly fromStart?: boolean | undefined };
+
+/** The span words with the range signs and names to read them, and the dated-span lexicon's entries they come from. */
+export type PairSpans = PeriodWords & { readonly entries: readonly OrderLabel[] };
+
+/**
+ * The span words a dated-span lexicon reads by the period's start in one group: its entries naming that group with
+ * position before. An entry without a group is read by the period's end in every group.
+ */
+export const spanStartsOf = (spanLabels: readonly OrderLabel[], group: string): string[] =>
+  spanLabels.filter((label) => label.group === group && label.position === "before").map((label) => label.pattern);
+
+/**
+ * The span words to read periods with, the whole document (its headings too) to read the words naming its kind, and the
+ * role words whose signature line gives a group's later date (a dated-signer lexicon's entries with position after).
+ */
+export type PairedReading = {
+  readonly spans?: PairSpans | undefined;
+  readonly whole?: string | undefined;
+  readonly signers?: readonly OrderLabel[] | undefined;
+  /** The words that join a version to a label (End of support for 5.0.0, 3.0.0 のサポート終了日). */
+  readonly versions?: VersionWords | undefined;
+};
+
+const signersOf = (signers: readonly OrderLabel[], group: string): string[] =>
+  signers.filter((label) => label.group === group && label.position === "after").map((label) => label.pattern);
+
+/** The words a group names its kind of document with: the group's entries without a position (見積, Quote). */
+const contextOf = (labels: readonly OrderLabel[], group: string): string[] =>
+  labels.filter((label) => label.group === group && label.position === undefined).map((label) => label.pattern);
+
+const sameDates = (one: PairedIssue, other: PairedIssue): boolean =>
+  one.offset === other.offset && one.values["later"] === other.values["later"] && one.values["earlier"] === other.values["earlier"];
+
+/**
+ * The issues, two groups comparing one later date with the same earlier date reported once (a leaver's issue date before
+ * both the leaving date and the end of the period covered, which is the same day). Different earlier dates are kept.
+ */
+const withoutRepeats = (issues: readonly PairedIssue[]): PairedIssue[] =>
+  issues.filter((issue, index) => issues.findIndex((other) => sameDates(other, issue)) === index);
 
 /**
  * Every pair of a dated-pair lexicon: the entries of one group with position before label the earlier date, those with
  * position after the later one. The values name both labels, so the message can quote them. The issue is on whichever
  * of the two dates is written second: a reader meets the contradiction there (a cancellation deadline below check-in).
+ * A group with entries without a position is read only in a document whose title or a field's label names one of them
+ * (namesDocumentKind, over reading.whole: the document with its headings, which source blanks out): ご利用日 before 有効期限 is a
+ * quote's mistake and a points statement's normal order.
+ * reading.spans.entries are the dated-span lexicon's entries, for the span words a group reads by the period's start.
  */
 export const pairedDatesOutOfOrder = (
   source: string,
@@ -89,12 +169,19 @@ export const pairedDatesOutOfOrder = (
   labels: readonly OrderLabel[],
   passed: readonly string[],
   maxLineGap: number,
-  spans?: PeriodWords,
+  { spans, whole = source, signers = [], versions }: PairedReading = {},
 ): PairedIssue[] =>
-  labelPairsOf(labels).flatMap((pair) =>
-    datesOutOfOrder(source, dates, { ...pair, passed, maxLineGap, spans }).map(({ earlier, later }) => ({
-      offset: Math.max(later.date.offset, earlier.date.offset),
-      values: { later: later.date.value, earlier: earlier.date.value, later_label: later.label, earlier_label: earlier.label },
-      period: earlier.span,
-    })),
+  withoutRepeats(
+    labelPairsOf(labels).flatMap((pair) => {
+      const context = contextOf(labels, pair.group);
+      if (context.length > 0 && !namesDocumentKind(whole, context)) return [];
+      const fromStart = spanStartsOf(spans?.entries ?? [], pair.group);
+      const words = { ...pair, passed, maxLineGap, spans, fromStart, signers: signersOf(signers, pair.group), versions };
+      return datesOutOfOrder(source, dates, words).map(({ earlier, later }) => ({
+        offset: Math.max(later.date.offset, earlier.date.offset),
+        values: { later: later.date.value, earlier: earlier.date.value, later_label: later.label, earlier_label: earlier.label },
+        period: earlier.span,
+        ...(earlier.span && fromStart.includes(earlier.label) ? { fromStart: true } : {}),
+      }));
+    }),
   );

package/src/structure/labelled-order.ts

@@ -1,6 +1,8 @@
 import { linesOf, type Line } from "./lines.ts";
 import { tableAround } from "./key-value-row.ts";
+import { signerRoleOf } from "./signed-date-line.ts";
 import { isTotalLabel } from "./total.ts";
+import { withoutLabelVersion, type VersionWords } from "./versioned-label.ts";
 
 /**
  * Two labelled points that must come in order: a line (or a list item, or a table's first column) starting with an
@@ -18,6 +20,13 @@ export type PairWords = {
   readonly passed: readonly string[];
   /** How many lines from the earlier point a later point may be and still be read as the same record's. */
   readonly maxLineGap: number;
+  /**
+   * Role words whose line, when no label heads it, may give a later point (a signature: 2026年4月12日 会計監査 戸川 隆).
+   * pointOf decides whether the line is one. A signature closes the whole document, so it is read at any distance.
+   */
+  readonly signers?: readonly string[] | undefined;
+  /** The words that join a version to a label (End of support for 5.0.0, 3.0.0 のサポート終了日). */
+  readonly versions?: VersionWords | undefined;
 };
 
 /** A labelled point: the word that labels it, as the lexicon writes it. span is set when the point ends a stated period. */
@@ -28,17 +37,30 @@ export type PointPair = { readonly earlier: LabelledPoint; readonly later: Label
 /** The point a labelled line gives, or undefined when it gives none. tableOf gives the table the line is a row of. */
 export type PointOf = (line: Line, label: string, tableOf: () => readonly string[]) => Pick<LabelledPoint, "point" | "span"> | undefined;
 
-type Read = LabelledPoint & { readonly kind: "earlier" | "later" };
+type Read = LabelledPoint & { readonly kind: "earlier" | "later"; readonly signed?: boolean | undefined };
+
+const isVersionedLabel = (text: string, word: string, versions: VersionWords | undefined): boolean => {
+  const bare = versions === undefined ? undefined : withoutLabelVersion(text, word, versions);
+  return bare !== undefined && isTotalLabel(bare, [word]);
+};
 
-const labelOf = (text: string, words: readonly string[]): string | undefined => words.find((word) => isTotalLabel(text, [word]));
+const labelOf = (text: string, words: readonly string[], versions?: VersionWords): string | undefined =>
+  words.find((word) => isTotalLabel(text, [word]) || isVersionedLabel(text, word, versions));
 
-const kindOf = (text: string, words: PairWords): Pick<Read, "kind" | "label"> | undefined => {
-  const earlier = labelOf(text, words.earlier);
+const signerOf = (text: string, words: PairWords): Pick<Read, "kind" | "label" | "signed"> | undefined => {
+  const role = signerRoleOf(text, words.signers ?? []);
+  return role === undefined ? undefined : { kind: "later", label: role, signed: true };
+};
+
+const kindOf = (text: string, words: PairWords): Pick<Read, "kind" | "label" | "signed"> | undefined => {
+  const earlier = labelOf(text, words.earlier, words.versions);
   if (earlier !== undefined) return { kind: "earlier", label: earlier };
-  const later = labelOf(text, words.later);
-  return later === undefined ? undefined : { kind: "later", label: later };
+  const later = labelOf(text, words.later, words.versions);
+  return later === undefined ? signerOf(text, words) : { kind: "later", label: later };
 };
 
+const withinGap = (later: Read, earlier: Read, maxLineGap: number): boolean => later.signed === true || Math.abs(later.line - earlier.line) < maxLineGap;
+
 const labelledPoints = (source: string, words: PairWords, pointOf: PointOf): Read[] => {
   const lines = linesOf(source);
   const texts = lines.map((line) => line.text);
@@ -75,7 +97,7 @@ export type PairReading = {
 const nearestOutOfOrder = (labelled: readonly Read[], earliers: readonly Read[], maxLineGap: number): PointPair[] =>
   labelled.flatMap((later) => {
     const earlier = later.kind === "later" ? nearestEarlier(earliers, later) : undefined;
-    return earlier !== undefined && later.point.value < earlier.point.value && Math.abs(later.line - earlier.line) < maxLineGap ? [{ earlier, later }] : [];
+    return earlier !== undefined && later.point.value < earlier.point.value && withinGap(later, earlier, maxLineGap) ? [{ earlier, later }] : [];
   });
 
 /**
@@ -89,10 +111,7 @@ const firstOutOfOrder = (labelled: readonly Read[], earliers: readonly Read[], m
   const records = labelled.filter((entry) => entry.kind === "later").length > 1;
   const beforeOwnRecord = (later: Read): boolean => !records || later.point.value < (nearestEarlier(earliers, later) ?? earlier).point.value;
   return labelled
-    .filter(
-      (entry) =>
-        entry.kind === "later" && entry.point.value < earlier.point.value && Math.abs(entry.line - earlier.line) < maxLineGap && beforeOwnRecord(entry),
-    )
+    .filter((entry) => entry.kind === "later" && entry.point.value < earlier.point.value && withinGap(entry, earlier, maxLineGap) && beforeOwnRecord(entry))
     .map((later) => ({ earlier, later }));
 };
 
@@ -108,8 +127,8 @@ export const pointsOutOfOrder = (source: string, words: PairWords, pointOf: Poin
 /** A lexicon entry naming its pair (group) and its side: before for the earlier point, after for the later one. */
 export type OrderLabel = { readonly pattern: string; readonly group?: string | undefined; readonly position?: "before" | "after" | undefined };
 
-/** One pair of a lexicon: the words of its group that label the earlier point, and those that label the later one. */
-export type LabelPair = { readonly earlier: string[]; readonly later: string[] };
+/** One pair of a lexicon: its group, the words of the group that label the earlier point, and those that label the later one. */
+export type LabelPair = { readonly group: string; readonly earlier: string[]; readonly later: string[] };
 
 const sideOf = (labels: readonly OrderLabel[], group: string, position: "before" | "after"): string[] =>
   labels.filter((label) => label.group === group && label.position === position).map((label) => label.pattern);
@@ -117,6 +136,7 @@ const sideOf = (labels: readonly OrderLabel[], group: string, position: "before"
 /** Every pair a lexicon names, in the order its groups first appear. */
 export const labelPairsOf = (labels: readonly OrderLabel[]): LabelPair[] =>
   [...new Set(labels.flatMap((label) => (label.group === undefined ? [] : [label.group])))].map((group) => ({
+    group,
     earlier: sideOf(labels, group, "before"),
     later: sideOf(labels, group, "after"),
   }));

package/src/structure/line-amount-label.ts

@@ -3,7 +3,8 @@ import { linesOf, type Line } from "./lines.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { roundedMatches } from "./tax.ts";
 import { hasSuperscriptPower } from "../facts/superscript-power.ts";
-import { cellNumber, cellsOf, plain, shownExpected, tablesOf, type Cell, type CellNumber } from "./line-amount.ts";
+import { cellNumber, cellsOf, plain, shownExpected, type Cell, type CellNumber } from "./line-amount.ts";
+import { tablesOf } from "../facts/table-facts.ts";
 
 /**
  * line-amount-mismatch, the product written in an item cell: 「| 会費（3,000円×24名） | 72,000円 |」,

package/src/structure/line-amount.ts

@@ -1,7 +1,7 @@
 import type { StructureIssue } from "./issues.ts";
 import { linesOf, type Line } from "./lines.ts";
 import { CELL_SEPARATOR } from "./bare-numbers.ts";
-import { TABLE_RULE } from "./runs.ts";
+import { tablesOf } from "../facts/table-facts.ts";
 import { roundedMatches } from "./tax.ts";
 import { holds } from "./change-rate-table.ts";
 import { roleOf, type QuantityRole, type QuantityWord } from "./order-quantity.ts";
@@ -297,16 +297,6 @@ const rowIssue = (row: Line, table: Table, words: LineAmountWords): StructureIss
   return [{ offset: amount.offset, values }];
 };
 
-/** Each table: its header row and its body rows. */
-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 [];
-    const after = lines.slice(index + 1);
-    const end = after.findIndex((row) => !row.text.includes("|"));
-    return [{ header, rows: end === -1 ? after : after.slice(0, end) }];
-  });
-
 export const lineAmountMismatches = (source: string, words: LineAmountWords): StructureIssue[] =>
   tablesOf(linesOf(source)).flatMap(({ header, rows }) => {
     const readings = [tableOf(cellsOf(header), words), packTableOf(cellsOf(header), words)];