chaffjs 0.33.0 → 0.34.0

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

@@ -1,8 +1,10 @@
+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 { isSignedDateLine } from "./signed-date-line.ts";
 import { statedPeriod, type DateMention, type PeriodWords } from "./stated-period.ts";
 
 /**
@@ -10,11 +12,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 +34,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 +50,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 +106,59 @@ 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;
+};
+
+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 +166,19 @@ export const pairedDatesOutOfOrder = (
   labels: readonly OrderLabel[],
   passed: readonly string[],
   maxLineGap: number,
-  spans?: PeriodWords,
+  { spans, whole = source, signers = [] }: 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) };
+      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,5 +1,6 @@
 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";
 
 /**
@@ -18,6 +19,11 @@ 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;
 };
 
 /** 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 +34,24 @@ 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 labelOf = (text: string, words: readonly string[]): string | undefined => words.find((word) => isTotalLabel(text, [word]));
 
-const kindOf = (text: string, words: PairWords): Pick<Read, "kind" | "label"> | undefined => {
+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);
   if (earlier !== undefined) return { kind: "earlier", label: earlier };
   const later = labelOf(text, words.later);
-  return later === undefined ? undefined : { kind: "later", label: later };
+  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 +88,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 +102,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 +118,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 +127,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)];

package/src/structure/prose-total.ts

@@ -5,6 +5,8 @@ import { shownTotal, type Amount } from "./total.ts";
  * 文の中で書いた合計と内訳。表や箇条書きでなく、一つの文に並べた金額を読む。二つの形がある。
  *   内訳のあとに合計:  「保守費60,000円、運用費30,000円とし、合計100,000円とする」 "$6,000 for hosting and $3,000 for support, for a total of $9,000"
  *   合計のあとに内訳:  「月額150,000円（内訳：保守費90,000円、運用費60,000円）」 "costs $8 per month, made up of a base fee of $6 and a storage fee of $2"
+ *   合計の語のあとに内訳:  「総額12,000円：設計5,000円、開発6,000円」 "a total of $12,000: $5,000 for design and $6,000 for development"
+ *     （内訳を始める記号や語 total-breakdown-lead が合計の金額のすぐ後ろにあるか、合計で終わる文の次の文が内訳の語で始まるとき）
  * 合計の語（total-phrase）はすぐ後ろに合計の金額が来る語、内訳の語（breakdown-phrase）はすぐ後ろから内訳が始まる語。
  * 内訳は合計と同じ単位の金額で、二つ以上。合計の語のすぐ前（内訳の語のすぐ後ろ）から続く並びのどれかの和が合計と合えば
  * 合っているとみなし、どれとも合わないときだけ言う。文の中のほかの金額（単価・上限・遅延損害金）を内訳に数えて誤って言わないため。
@@ -16,6 +18,12 @@ export type TotalWords = {
   readonly breakdowns: readonly string[];
   readonly discounts: readonly string[];
   readonly joiners: readonly string[];
+  /** 合計の金額のすぐ後ろに書いて、そこから内訳のすべてが続くことを言う記号や語（": $5,000 for design and …"）。 */
+  readonly leads: readonly string[];
+  /** 合計と内訳のあいだにあれば、後ろの金額は合計の内訳のすべてとは限らないと読む語（including、うち、or）。 */
+  readonly partials: readonly string[];
+  /** 次の文で内訳の語の前に書いて、前の文の合計を指す語（This、It、その）。何も書かなくてもよい。 */
+  readonly backReferences: readonly string[];
 };
 
 type Span = { readonly start: number; readonly end: number };
@@ -124,12 +132,83 @@ const totalsBeforeParts = (source: string, sentence: Span, amounts: readonly Amo
   });
 };
 
+/** 合計の金額と、後ろに続く内訳を始める記号や語のあいだに書いてよいもの: 空白と、読点一つ。 */
+const isLeadGap = (gap: string): boolean => /^[、,，]?$/u.test(gap.trim());
+/** 割合（40%）を並べた内訳は、金額が合計のどの部分かを言わないので比べない。 */
+const PERCENT = /[%％]/u;
+/** 合計の文と内訳の文のあいだに空行があれば、別の段落で、続く内訳とは読まない。 */
+const PARAGRAPH_BREAK = /\n\s*\n/u;
+
+/** 合計の語のすぐ後ろの金額。 */
+const totalsAt = (source: string, markers: readonly Span[], amounts: readonly Amount[]): Amount[] =>
+  markers.flatMap((marker) => amounts.find((amount) => amount.offset >= marker.end && isTotalGap(gapBefore(source, marker.end, amount))) ?? []);
+
+/**
+ * 合計の後ろから始まる内訳のすべてを合計と比べる。内訳の金額がどれも合計と同じ単位で、合計から内訳の終わりまでに
+ * 一部だけを言う語（including、うち）も割合も無いときだけ。
+ */
+const fullBreakdown = (source: string, total: Amount, listed: readonly Amount[], from: number, words: TotalWords): StructureIssue[] => {
+  const last = listed.at(-1);
+  if (last === undefined || listed.some((part) => part.unit !== total.unit)) return [];
+  const between = source.slice(total.end, last.offset);
+  if (PERCENT.test(between) || phraseSpans(between, total.end, words.partials).length > 0) return [];
+  return mismatch(source, { total, parts: listed, from, nearEnd: false }, words.discounts);
+};
+
+/** 文の中で、合計の語の金額のすぐ後ろに内訳を始める記号や語（": "）があれば、その後ろから文の終わりか次の記号までが内訳。 */
+const totalsThenLead = (source: string, sentence: Span, amounts: readonly Amount[], words: TotalWords): StructureIssue[] => {
+  const text = source.slice(sentence.start, sentence.end);
+  const markers = phraseSpans(text, sentence.start, words.totals);
+  const leads = phraseSpans(text, sentence.start, words.leads);
+  return totalsAt(source, markers, amounts).flatMap((total) => {
+    const lead = leads.find((span) => span.start >= total.end && isLeadGap(source.slice(total.end, span.start)));
+    if (lead === undefined) return [];
+    const end = Math.min(sentence.end, ...[...leads, ...markers].filter((span) => span.start >= lead.end).map((span) => span.start));
+    return fullBreakdown(source, total, inside(amounts, lead.end, end), lead.end, words);
+  });
+};
+
+/** 文の最後の金額が合計の語のすぐ後ろの金額なら、その金額。 */
+const closingTotal = (source: string, sentence: Span, amounts: readonly Amount[], words: TotalWords): Amount | undefined => {
+  const last = inside(amounts, sentence.start, sentence.end).at(-1);
+  const markers = phraseSpans(source.slice(sentence.start, sentence.end), sentence.start, words.totals);
+  return totalsAt(source, markers, amounts).find((total) => total === last);
+};
+
+/** 内訳の語の前に書いたものが、何も無いか前の合計を指す語だけ（"This consists of" 「内訳は」「その内訳は」）。 */
+const refersBack = (opening: string, backReferences: readonly string[]): boolean => {
+  const subject = opening.trim().toLowerCase();
+  return subject === "" || backReferences.some((word) => word.toLowerCase() === subject);
+};
+
+/** 合計で終わる文のすぐ次の文が、前の合計を指して内訳の語で始まれば（内訳は、This consists of）、その後ろの金額が内訳。 */
+const totalThenNextSentence = (source: string, pair: readonly [Span, Span], amounts: readonly Amount[], words: TotalWords): StructureIssue[] => {
+  const [previous, next] = pair;
+  const total = closingTotal(source, previous, amounts, words);
+  if (total === undefined || PARAGRAPH_BREAK.test(source.slice(previous.end, next.start))) return [];
+  const text = source.slice(next.start, next.end);
+  const marker = phraseSpans(text, next.start, words.breakdowns)[0];
+  if (marker === undefined || !refersBack(source.slice(next.start, marker.start), words.backReferences)) return [];
+  const inNext = inside(amounts, next.start, next.end);
+  const end = phraseSpans(text, next.start, words.totals).find((span) => span.start >= marker.end)?.start ?? next.end;
+  return fullBreakdown(source, total, inside(inNext, marker.end, end), marker.end, words);
+};
+
 /** 文ごとに、書いた合計が内訳の和と合わない所。一つの金額は一度だけ言う。 */
 export const proseTotalMismatches = (source: string, sentences: readonly Span[], amounts: readonly Amount[], words: TotalWords): StructureIssue[] => {
-  const issues = sentences.flatMap((sentence) => {
+  const inSentences = sentences.flatMap((sentence) => {
     const inSentence = inside(amounts, sentence.start, sentence.end);
     if (inSentence.length <= MIN_PARTS) return [];
-    return [...totalsAfterParts(source, sentence, inSentence, words), ...totalsBeforeParts(source, sentence, inSentence, words)];
+    return [
+      ...totalsAfterParts(source, sentence, inSentence, words),
+      ...totalsBeforeParts(source, sentence, inSentence, words),
+      ...totalsThenLead(source, sentence, inSentence, words),
+    ];
+  });
+  const acrossSentences = sentences.flatMap((previous, index) => {
+    const next = sentences[index + 1];
+    return next === undefined ? [] : totalThenNextSentence(source, [previous, next], amounts, words);
   });
+  const issues = [...inSentences, ...acrossSentences];
   return issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
 };

package/src/structure/runs.ts

@@ -1,3 +1,5 @@
+import { fencedLineIndexes } from "./fenced-lines.ts";
+
 /**
  * 箇条書きと表の行の並び。続いた箇条書きの同じ深さの項目か、続いた表の行を一つの並びとして読む。
  * 並びの中の値（日付、金額）を比べる rule が共通に使う。
@@ -29,14 +31,21 @@ const pipelessTableLines = (texts: readonly string[]): Set<number> => {
   return inTable;
 };
 
+/** コードブロックの中の箇条書きや表は例なので、並びにしない。 */
+const kindAt = (texts: readonly string[], index: number, pipeless: ReadonlySet<number>, fenced: ReadonlySet<number>): Kind | undefined => {
+  if (fenced.has(index)) return undefined;
+  return pipeless.has(index) ? "table" : kindOf(texts[index] ?? "");
+};
+
 const linesOf = (source: string): Line[] => {
   const texts = source.split("\n");
   const pipeless = pipelessTableLines(texts);
+  const fenced = fencedLineIndexes(texts);
   const found: Line[] = [];
   let start = 0;
   texts.forEach((text, index) => {
     const indent = INDENT.exec(text)?.[0].length ?? 0;
-    const kind = pipeless.has(index) ? "table" : kindOf(text);
+    const kind = kindAt(texts, index, pipeless, fenced);
     found.push({ start, end: start + text.length, kind, indent, rule: TABLE_RULE.test(text) });
     start += text.length + 1;
   });

package/src/structure/signed-date-line.ts

@@ -0,0 +1,78 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * A signature line that dates what its signer did: one date, one role word and the signer's name, and nothing else
+ * (2026年4月12日 会計監査 戸川 隆; Jane Doe, Honorary Auditor, April 12, 2026). A sentence (2026年3月26日の定期総会で承認),
+ * a line without a name, or a line naming two people is not one. Pure.
+ */
+
+const SEPARATOR = /[\s,、，:：]/u;
+const MARK = /[,、，:：]/u;
+const SPACES = /\s+/u;
+/** A Japanese name is one or two parts (戸川 隆, 戸川隆); an English one two or three (Jane Doe, Jane Q. Doe). */
+const MAX_JA_NAME_PARTS = 2;
+const MIN_EN_NAME_PARTS = 2;
+const MAX_EN_NAME_PARTS = 3;
+/** A Japanese name part is kanji or katakana: hiragana is a particle or a verb (田中が確認, に監査を受け). */
+const JA_NAME_PART = /^[\p{Script=Han}\p{Script=Katakana}ー]{1,5}$/u;
+/** An English name part is capitalised, or an initial with its full stop. */
+const EN_NAME_PART = /^\p{Lu}(?:\.|[\p{L}'’-]+)$/u;
+
+/** Where a date sits on the line: from start to end, counted from the line's start. */
+export type LineSpan = { readonly start: number; readonly end: number };
+
+const isEdge = (text: string, index: number): boolean => index < 0 || index >= text.length || SEPARATOR.test(text.charAt(index));
+
+const standsAlone = (text: string, start: number, end: number): boolean => isEdge(text, start - 1) && isEdge(text, end);
+
+const occurrences = (text: string, word: string): number[] => [...text.matchAll(new RegExp(escapeRegExp(word), "gu"))].map((match) => match.index);
+
+/** The role word of roles standing alone on the line (between separators or at an edge), the longest first. */
+export const signerRoleOf = (text: string, roles: readonly string[]): string | undefined =>
+  [...roles]
+    .sort((one, other) => other.length - one.length)
+    .find((role) => occurrences(text, role).some((start) => standsAlone(text, start, start + role.length)));
+
+const isJaName = (parts: readonly string[]): boolean => parts.length <= MAX_JA_NAME_PARTS && parts.every((part) => JA_NAME_PART.test(part));
+
+const isEnName = (parts: readonly string[]): boolean =>
+  parts.length >= MIN_EN_NAME_PARTS && parts.length <= MAX_EN_NAME_PARTS && parts.every((part) => EN_NAME_PART.test(part));
+
+const blanked = (text: string, span: LineSpan): string => `${text.slice(0, span.start)}${" ".repeat(span.end - span.start)}${text.slice(span.end)}`;
+
+/** Where the text that is not a separator starts and ends; undefined when there is none. */
+const contentOf = (text: string): LineSpan | undefined => {
+  const units = text.split("");
+  const start = units.findIndex((unit) => !SEPARATOR.test(unit));
+  if (start < 0) return undefined;
+  const end = units.findLastIndex((unit) => !SEPARATOR.test(unit)) + 1;
+  return { start, end };
+};
+
+/** The text between the role and the name: the name sits wholly on one side of the role. */
+const gapOf = (text: string, role: LineSpan, name: LineSpan): string | undefined => {
+  if (name.end <= role.start) return text.slice(name.end, role.start);
+  return name.start >= role.end ? text.slice(role.end, name.start) : undefined;
+};
+
+/**
+ * The line is a signature: the date and the role each stand alone, and what is left is one name, in one piece on one side
+ * of the role (山田太郎、佐藤花子 is two). An English name is set off from its role by a comma or a colon (Jane Doe, Auditor),
+ * so a title (Auditor Annual Report) is not one. The role is found once the date is blanked out, so a role word inside the
+ * date's text is not read.
+ */
+export const isSignedDateLine = (text: string, role: string, date: LineSpan): boolean => {
+  if (!standsAlone(text, date.start, date.end)) return false;
+  const withoutDate = blanked(text, date);
+  const roleStart = occurrences(withoutDate, role).find((start) => standsAlone(withoutDate, start, start + role.length));
+  if (roleStart === undefined) return false;
+  const roleSpan = { start: roleStart, end: roleStart + role.length };
+  const rest = blanked(withoutDate, roleSpan);
+  const name = contentOf(rest);
+  const gap = name === undefined ? undefined : gapOf(withoutDate, roleSpan, name);
+  if (name === undefined || gap === undefined) return false;
+  const nameText = rest.slice(name.start, name.end);
+  if (MARK.test(nameText)) return false;
+  const parts = nameText.split(SPACES);
+  return isJaName(parts) || (isEnName(parts) && MARK.test(gap));
+};

package/src/structure/tax.ts

@@ -1,6 +1,6 @@
 import type { StructureIssue } from "./issues.ts";
 import { runsOf, type Line } from "./runs.ts";
-import { columnOf, isTotalLabel, shownTotal, type Amount } from "./total.ts";
+import { columnOf, isTotalLabel, shownTotal, withoutLeadingBlankCells, type Amount } from "./total.ts";
 
 /**
  * 税の行と、その上の金額に率を掛けた額。表か箇条書きの並びで、税の語（消費税・Sales tax）で始まり率（10%）を書いた行の
@@ -42,8 +42,11 @@ const rateOf = (text: string): number | undefined => {
   return Number.isFinite(rate) && rate > 0 && rate < MAX_RATE ? rate : undefined;
 };
 
+/** A tax or total row may leave its first cells blank and put its word in the first cell that is not (| | 小計 | 12,000円 |). */
+const startsWithLabel = (row: Row, labels: readonly string[]): boolean => isTotalLabel(withoutLeadingBlankCells(row.text), labels);
+
 const isTaxRow = (row: Row, words: TaxWords): boolean =>
-  isTotalLabel(row.text, words.labels) && !words.included.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
+  startsWithLabel(row, words.labels) && !words.included.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
 
 const isChargeRow = (row: Row, words: TaxWords): boolean => isTotalLabel(row.text, words.charges) && rateOf(row.text) !== undefined;
 
@@ -89,7 +92,7 @@ const basesOf = (source: string, above: readonly Row[], tax: Amount, column: num
   const charges = valuesAt(source, above.slice(chargeStart), column, tax.unit);
   if (charges === undefined) return [];
   const before = above.slice(0, chargeStart);
-  const lastTotalIndex = before.findLastIndex((row) => isTotalLabel(row.text, words.totals));
+  const lastTotalIndex = before.findLastIndex((row) => startsWithLabel(row, words.totals));
   const lastTotal = before[lastTotalIndex];
   if (lastTotal !== undefined) {
     const total = amountAt(source, lastTotal, column, tax.unit);

package/src/structure/total-line.ts

@@ -1,4 +1,4 @@
-import { isTotalLabel, leadingText } from "./total.ts";
+import { isTotalLabel, leadingText, withoutLeadingBlankCells } from "./total.ts";
 import { CELL_SEPARATOR } from "./bare-numbers.ts";
 import { outsideBrackets } from "./connection-times.ts";
 
@@ -45,7 +45,13 @@ const labelText = (lead: string): string => {
 };
 
 /** 行頭の見出しを語に分ける。括弧の注記（(incl. tax)）と強調の印は除く。 */
-const labelWords = (text: string): string[] => wordsOf(outsideBrackets(labelText(leadingText(text))).replace(EMPHASIS, ""));
+const leadingLabelWords = (text: string): string[] => wordsOf(outsideBrackets(labelText(leadingText(text))).replace(EMPHASIS, ""));
+
+/** 行の見出しの語。表の行は、前の升がどれも空なら、最初の空でない升の見出しを読む。 */
+const labelWords = (text: string): string[] => leadingLabelWords(withoutLeadingBlankCells(text));
+
+/** 見出しの語で始まる行か。表の行は、前の升がどれも空なら、最初の空でない升に書いた見出しも読む（| | 合計 | 12,000円 |）。 */
+const startsWithLabel = (text: string, labels: readonly string[]): boolean => isTotalLabel(withoutLeadingBlankCells(text), labels);
 
 const startsAt = (words: readonly string[], label: readonly string[], index: number): boolean => label.every((word, offset) => words[index + offset] === word);
 
@@ -153,8 +159,8 @@ const isUnsummed = (nouns: readonly string[], unsummedNouns: readonly string[]):
  */
 const isNamedTotal = (text: string, words: TotalLineWords, header: string): boolean => {
   const label = labelWords(text).join(" ");
-  const firstColumn = labelWords(header);
-  const columns = summedColumnHeaders(text, header).map(labelWords);
+  const firstColumn = leadingLabelWords(header);
+  const columns = summedColumnHeaders(text, header).map(leadingLabelWords);
   const namesTotal = (nouns: readonly string[]): boolean =>
     !isUnsummed(nouns, words.unsummedNouns ?? []) &&
     (namesEachOther(nouns, firstColumn) || (columns.length > 0 && columns.every((headerWords) => namesEachOther(nouns, headerWords))));
@@ -163,7 +169,7 @@ const isNamedTotal = (text: string, words: TotalLineWords, header: string): bool
 
 /** 合計の語だけか、合計の語に添える語だけを前後に置いた見出しか。 */
 const isPlainTotal = (text: string, words: TotalLineWords): boolean => {
-  if (isTotalLabel(text, words.labels)) return true;
+  if (startsWithLabel(text, words.labels)) return true;
   if (words.qualifiers.length === 0) return false;
   const label = labelWords(text);
   return words.labels.some((total) => isQualifiedLabel(label, wordsOf(total), words.qualifiers));
@@ -189,7 +195,7 @@ export const withoutPeriod = (label: string, qualifier: TotalQualifier): string
  * 前の年の合計（前年合計、Prior-year total）は、期間の語が頭にも尻にも無いので読まない。
  */
 export const isPeriodTotalLine = (text: string, words: TotalLineWords): boolean => {
-  if (isTotalLabel(text, words.periodLabels ?? [])) return true;
+  if (startsWithLabel(text, words.periodLabels ?? [])) return true;
   const label = labelWords(text).join(" ");
   return (words.periodQualifiers ?? []).some((qualifier) => {
     const rest = withoutPeriod(label, qualifier);