chaffjs 0.24.0 → 0.26.0

package/src/run.ts

@@ -15,7 +15,7 @@ import { presetLevels } from "./genre-load.ts";
 import { bodySectionOf } from "./body-section.ts";
 import { optionValues, settleOptions, type OptionLayer } from "./rule-options.ts";
 import { byPosition } from "./finding-order.ts";
-import { PatternTimeout } from "./custom/bounded-match.ts";
+import { PatternTimeout } from "./custom/pattern-timeout.ts";
 import { PluginRuleFailure } from "./extension/module-detector.ts";
 import { failureReason } from "./extension/failure-text.ts";
 import { tagCoverage } from "./tag-coverage.ts";

package/src/structure/date-range.ts

@@ -18,6 +18,29 @@ export type RangeWords = {
   readonly frames: readonly RangeFrame[];
   /** 同じ文にあれば、組を期間ではなく日付の変更と読む語（moved from … to、… was postponed）。 */
   readonly changes: readonly string[];
+  /** 日付の前に添える曜日の名（Wednesday, April 1, 2026）。つなぎ目と前の語を読むときに除く。無ければ空。 */
+  readonly weekdays?: readonly string[];
+};
+
+/** 曜日の略し方の短いほう（Tue、Wed）。名の頭のこの字数以上が書いてあれば、その曜日と読む。 */
+const WEEKDAY_ABBREVIATION = 3;
+const LETTER = /\p{L}/u;
+
+/** The text's last word (past a full stop) and where it starts. */
+const lastWord = (text: string): { readonly word: string; readonly start: number } => {
+  const body = text.endsWith(".") ? text.slice(0, -1) : text;
+  const chars = [...body];
+  const start = chars.findLastIndex((char) => !LETTER.test(char)) + 1;
+  return { word: chars.slice(start).join(""), start: chars.slice(0, start).join("").length };
+};
+
+/** 終わりに付いた曜日の名か略し方とその後ろのコンマ（"to tuesday," の tuesday,、"from wed." の wed.）を除く。 */
+export const withoutTrailingWeekday = (text: string, weekdays: readonly string[]): string => {
+  const trimmed = text.replace(/,$/u, "").trimEnd();
+  const { word, start } = lastWord(trimmed);
+  const lower = word.toLowerCase();
+  const isWeekday = lower.length >= WEEKDAY_ABBREVIATION && weekdays.some((name) => name.toLowerCase().startsWith(lower));
+  return isWeekday ? trimmed.slice(0, start).trimEnd() : text;
 };
 
 export type RangeFrame = { readonly lead: string; readonly joint: string };
@@ -87,13 +110,15 @@ const sentenceAround = (source: string, start: DatedSpan, end: DatedSpan): { rea
 /** 前の語と間の語の組（from … to）。同じ文のどこかに変更の語（moved、postponed）があれば、日付を動かした文で、期間ではない。 */
 const framed = (source: string, start: DatedSpan, end: DatedSpan, joint: string, words: RangeWords): boolean => {
   const sentence = sentenceAround(source, start, end);
-  const frame = words.frames.find((candidate) => candidate.joint === joint && endsWithWord(sentence.before, candidate.lead));
+  const before = withoutTrailingWeekday(sentence.before, words.weekdays ?? []);
+  const frame = words.frames.find((candidate) => candidate.joint === joint && endsWithWord(before, candidate.lead));
   return frame !== undefined && !words.changes.some((change) => hasWord(sentence.text, change.toLowerCase()));
 };
 
 const isRange = (source: string, start: DatedSpan, end: DatedSpan, words: RangeWords): boolean => {
-  const joint = jointOf(source, start, end);
-  if (joint === undefined) return false;
+  const written = jointOf(source, start, end);
+  if (written === undefined) return false;
+  const joint = withoutTrailingWeekday(written, words.weekdays ?? []);
   return (
     isOneOf(joint, words.connectors) || (isOneOf(joint, words.openers) && closedAfter(source, end, words.closers)) || framed(source, start, end, joint, words)
   );

package/src/structure/issues.ts

@@ -31,8 +31,9 @@ const textOf = (node: StructureNode, key: string): string => {
  * 参照がこの文書のどこかを指しているか。fallback は言語パッケージが付ける別の行き先で、
  * 日本語の「第4条第1項」は、番号の無い第 1 項を持つ第4条を指しうる。
  */
-const resolves = (node: StructureNode, addresses: ReadonlySet<string>): boolean =>
-  addresses.has(textOf(node, "target")) || (node.attrs["fallback"] !== undefined && addresses.has(fallbackKey(node)));
+const resolves = (node: StructureNode, addresses: ReadonlySet<string>, chapters: Chapters): boolean =>
+  addresses.has(textOf(node, "target")) ||
+  (node.attrs["fallback"] !== undefined && chapterReading(textOf(node, "target"), chapters).fallback && addresses.has(fallbackKey(node)));
 
 /**
  * fallbackLabel があれば、fallback はその見出しの番号で書かれた節点だけに当たる。
@@ -48,6 +49,53 @@ const addressesOf = (node: StructureNode): string[] =>
 
 const keysOf = (node: StructureNode): string[] => addressesOf(node).flatMap((address) => [address, labelled(address, textOf(node, "label"))]);
 
+/** An address without its numbers: the kind of unit it names (ch9 and ch10 are both ch). */
+const unitOf = (address: string): string => address.replaceAll(/[\d.]+/gu, "");
+
+/** The document's chapters: their addresses, and whether the one chapter is the document itself (its title, first of all). */
+export type Chapters = { readonly addresses: readonly string[]; readonly titled: boolean };
+
+/**
+ * How a document's chapters bear on a reference to a chapter (第9章, Chapter 9). Pure.
+ *   fallback: whether the reference may fall back to a numbered section ("## 9. …"). Only in a document with no chapter:
+ *     where chapters are written, a chapter reference names a chapter, and section 9 is not chapter 9.
+ *   elsewhere: the reference names a chapter of another file. A document that is one chapter (第10章 as its title, a series
+ *     of one chapter per file) holds no other chapter, so 第9章 is the next file's. Its own chapter is still its own.
+ */
+export const chapterReading = (target: string, chapters: Chapters): { readonly fallback: boolean; readonly elsewhere: boolean } => {
+  const shortAddresses = chapters.addresses.map((address) => address.slice(address.lastIndexOf("/") + 1));
+  const toChapter = new Set(shortAddresses.map(unitOf)).has(unitOf(target));
+  const series = chapters.titled && chapters.addresses.length === 1 && !shortAddresses.includes(target);
+  return { fallback: !toChapter, elsewhere: toChapter && series };
+};
+
+/** A chapter is the document's title when it is not under another heading (ch10, not h1/ch1) and nothing numbered comes before it. */
+const chaptersOf = (nodes: readonly StructureNode[]): Chapters => {
+  const chapters = nodes.filter((node) => node.kind === "chapter");
+  const first = nodes.find((node) => NUMBERED.has(node.kind));
+  const titled = chapters.length === 1 && first === chapters[0] && !(first?.address.includes("/") ?? true);
+  return { addresses: chapters.map((node) => node.address), titled };
+};
+
+/** What may stand between a chapter and the reference it qualifies: nothing (第1章第2条) or の (第1章の第2条). A list mark (第1章、第2条) names two. */
+const QUALIFIER_GAPS: ReadonlySet<string> = new Set(["", "の"]);
+
+/**
+ * The references that point into another file: a chapter reference read as elsewhere (chapterReading), and the reference
+ * right after one, which it qualifies (第1章の第2条 is article 2 of that other chapter).
+ */
+const elsewhereReferences = (nodes: readonly StructureNode[], source: string): ReadonlySet<StructureNode> => {
+  const chapters = chaptersOf(nodes);
+  const references = nodes.filter((node) => node.kind === "reference");
+  const elsewhere = new Set<StructureNode>();
+  references.forEach((node, index) => {
+    const before = references[index - 1];
+    const qualified = before !== undefined && elsewhere.has(before) && QUALIFIER_GAPS.has(source.slice(before.span.end, node.span.start).trim());
+    if (qualified || chapterReading(textOf(node, "target"), chapters).elsewhere) elsewhere.add(node);
+  });
+  return elsewhere;
+};
+
 /**
  * 他の文書を指す参照か。citedTag（"[HTTP-CACHING]"）は、書き方だけでは差し込み欄の "[BUYER-1]" と見分けられないので、
  * 文書がその語を一覧に載せているときだけ他の文書の名とみなす。
@@ -77,10 +125,12 @@ export const danglingReferences = (tree: StructureNode, source: string): Structu
   const otherNumbering = (node: StructureNode): boolean =>
     numberings.size > 0 && typeof numbering(node) === "string" && !numberings.has(String(numbering(node))) && citedElsewhere.has(numbering(node));
   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))
-    .filter((node) => !namesAbsentUnit(node, articleLabels))
-    .filter((node) => !resolves(node, addresses))
+    .filter((node) => !namesAbsentUnit(node, articleLabels) && !elsewhere.has(node))
+    .filter((node) => !resolves(node, addresses, chapters))
     .map((node) => ({ offset: node.span.start, values: { label: textOf(node, "label"), target: textOf(node, "target") } }));
 };
 
@@ -88,15 +138,20 @@ export const danglingReferences = (tree: StructureNode, source: string): Structu
  * 参照が指す節点。danglingReferences と同じ引き方（番地、章の短い番地、fallback）で、番号の付いたまとまりを引く。
  * 同じ鍵の節点が二つ以上ある（番号の振り直しや別表の条）ときは、どれを指すのか決まらないので undefined。
  */
-export const referenceResolver = (tree: StructureNode): ((reference: StructureNode) => StructureNode | undefined) => {
+export const referenceResolver = (tree: StructureNode, source: string): ((reference: StructureNode) => StructureNode | undefined) => {
+  const nodes = inDocumentOrder(tree);
+  const chapters = chaptersOf(nodes);
+  const elsewhere = elsewhereReferences(nodes, source);
   const byKey = new Map<string, StructureNode | null>();
   inDocumentOrder(tree)
     .filter((node) => NUMBERED.has(node.kind))
     .forEach((node) => keysOf(node).forEach((key) => byKey.set(key, byKey.has(key) && byKey.get(key) !== node ? null : node)));
   const resolve = (reference: StructureNode): StructureNode | undefined => {
+    if (elsewhere.has(reference)) return undefined;
     const target = byKey.get(textOf(reference, "target"));
     if (target !== undefined) return target ?? undefined;
-    return reference.attrs["fallback"] === undefined ? undefined : (byKey.get(fallbackKey(reference)) ?? undefined);
+    const fallback = reference.attrs["fallback"] !== undefined && chapterReading(textOf(reference, "target"), chapters).fallback;
+    return fallback ? (byKey.get(fallbackKey(reference)) ?? undefined) : undefined;
   };
   // Article 6 は Section 6 ではない。番号の書き方が両方にあって違えば、別の文書の条かもしれないので引かない。
   return (reference) => {

package/src/structure/party-role.ts

@@ -0,0 +1,94 @@
+import type { BodyText, DefinedTerm } from "./definition-use.ts";
+
+/**
+ * 当事者を、定めた呼び名でなく立場の語で書いた所（「乙」と定めたあとの「受託者」、the "Supplier" のあとの the Vendor）。
+ * 当事者の定義は、文の途中で括弧に入れて短い呼び名を定めた所のうち、呼び名が当事者の呼び名の語（甲・乙・当社）か立場の語
+ * そのもの（Supplier）であるもの、または括弧のすぐ前に会社の形（株式会社、Ltd）を書いたもの。語は言語パッケージの語彙表から取る。
+ * 立場の語は、それ自体を定義した語や、定義した語の一部として書いた所（Receiving Party と定義した所の Party）なら指さない。
+ */
+export type PartyWords = {
+  /** 当事者の立場の語（委託者、受託者、Supplier、Recipient）。 */
+  readonly roles: readonly string[];
+  /** 当事者の呼び名に使う語（甲、乙、当社、we）。 */
+  readonly shortNames: readonly string[];
+  /** 会社の形（株式会社、Ltd、Inc.）。 */
+  readonly companyForms: readonly string[];
+};
+
+export type Party = { readonly term: string; readonly end: number };
+export type RoleUse = { readonly offset: number; readonly role: string };
+
+/** 会社の形を探す、括弧の前の幅。名前一つ分。 */
+const NAME_REACH = 40;
+/** 語の前後の一字がこれなら、語は長い語の一部（再受託者、受託者側の「受託者」は語の一部でない側も含む）。 */
+const WORD_CHAR = /[\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}ー]/u;
+const LATIN_START = /^\p{Script=Latin}/u;
+/** 英語の立場の語は、冠詞か所有の語に続く大文字の語だけ（the Vendor）。小文字の the vendor は普通の名詞。 */
+const ENGLISH_LEAD = /(?:^|[^\p{L}])(?:the|The|each|Each|any|Any|such|Such)\s+$/u;
+const LEAD_REACH = 8;
+
+const occurrences = (text: string, word: string): number[] => {
+  const found: number[] = [];
+  let at = text.indexOf(word);
+  while (at !== -1) {
+    found.push(at);
+    at = text.indexOf(word, at + word.length);
+  }
+  return found;
+};
+
+const LETTER = /\p{L}/u;
+
+/** 英字の語は、英字の続き（Including の Inc）では語と読まない。 */
+const wordAt = (text: string, word: string, at: number): boolean =>
+  !LATIN_START.test(word) || (!LETTER.test(text.charAt(at - 1)) && !LETTER.test(text.charAt(at + word.length)));
+
+/** 括弧の前の名前に会社の形があるか。 */
+const namedCompanyBefore = (source: string, definition: DefinedTerm, forms: readonly string[]): boolean => {
+  const before = source.slice(Math.max(0, definition.span.start - NAME_REACH), definition.span.start);
+  return forms.some((form) => form !== "" && occurrences(before, form).some((at) => wordAt(before, form, at)));
+};
+
+/** 文書が当事者として定めた呼び名と、その定義の終わり。 */
+export const partiesOf = (source: string, terms: readonly DefinedTerm[], words: PartyWords): Party[] =>
+  terms
+    .filter((term) => term.inline)
+    .filter((term) => words.shortNames.includes(term.term) || words.roles.includes(term.term) || namedCompanyBefore(source, term, words.companyForms))
+    .map((term) => ({ term: term.term, end: term.span.end }));
+
+/** 英語の立場の語のあとに付いてよいもの: 複数形と所有の形（Vendors、Vendor's）。 */
+const ENGLISH_ENDING = /^(?:s|['’]s?)?(?![\p{L}\p{N}])/u;
+/** 文や項目の頭（"Vendor shall"、"1. Vendor shall"）。 */
+const CLAUSE_START = /^[\s\d.()*+-]*$/u;
+
+/** 英語の立場の語は、冠詞か所有の語のあと（the Vendor）か、文の頭の大文字の語だけ。小文字の the vendor は普通の名詞。 */
+const englishRoleAt = (text: BodyText, at: number, role: string): boolean => {
+  const before = text.text.slice(0, at);
+  return ENGLISH_ENDING.test(text.text.slice(at + role.length)) && (CLAUSE_START.test(before) || ENGLISH_LEAD.test(before.slice(-LEAD_REACH)));
+};
+
+const standsAlone = (source: string, text: BodyText, at: number, role: string): boolean => {
+  const offset = text.start + at;
+  if (WORD_CHAR.test(source.charAt(offset - 1))) return false;
+  return LATIN_START.test(role) ? englishRoleAt(text, at, role) : !/[\p{Script=Han}\p{Script=Katakana}ー]/u.test(source.charAt(offset + role.length));
+};
+
+/** 定義した語がこの位置を覆うか（Receiving Party の Party、本受託者規程の受託者）。 */
+const insideDefined = (source: string, offset: number, role: string, defined: readonly string[]): boolean =>
+  defined.some((term) => term !== role && term.includes(role) && occurrences(term, role).some((at) => source.startsWith(term, offset - at)));
+
+/**
+ * 当事者を定めた後（after より後）で、立場の語を書いた所。立場の語それ自体を定義した文書では、その語は呼び名なので指さない。
+ */
+export const roleUses = (source: string, texts: readonly BodyText[], roles: readonly string[], defined: readonly string[], after: number): RoleUse[] =>
+  roles
+    .filter((role) => role !== "" && !defined.includes(role))
+    .flatMap((role) =>
+      texts.flatMap((text) =>
+        occurrences(text.text, role)
+          .filter((at) => text.start + at > after && standsAlone(source, text, at, role) && !insideDefined(source, text.start + at, role, defined))
+          .map((at) => ({ offset: text.start + at, role })),
+      ),
+    )
+    .toSorted((left, right) => left.offset - right.offset)
+    .filter((use, index, all) => all.findIndex((other) => other.offset <= use.offset && use.offset < other.offset + other.role.length) === index);

package/src/structure/prose-total.ts

@@ -0,0 +1,135 @@
+import type { StructureIssue } from "./issues.ts";
+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"
+ * 合計の語（total-phrase）はすぐ後ろに合計の金額が来る語、内訳の語（breakdown-phrase）はすぐ後ろから内訳が始まる語。
+ * 内訳は合計と同じ単位の金額で、二つ以上。合計の語のすぐ前（内訳の語のすぐ後ろ）から続く並びのどれかの和が合計と合えば
+ * 合っているとみなし、どれとも合わないときだけ言う。文の中のほかの金額（単価・上限・遅延損害金）を内訳に数えて誤って言わないため。
+ * 値引きの語（discount-word）のすぐ後ろの金額は引く。内訳の語の前の金額は、あいだに並びをつなぐ語（breakdown-gap-joiner）が
+ * あれば、別の項目の金額で合計ではない（a $1,000 onboarding fee and a monthly subscription, consisting of …）。
+ */
+export type TotalWords = {
+  readonly totals: readonly string[];
+  readonly breakdowns: readonly string[];
+  readonly discounts: readonly string[];
+  readonly joiners: readonly string[];
+};
+
+type Span = { readonly start: number; readonly end: number };
+
+const CENTS = 100;
+const MIN_PARTS = 2;
+
+/** 合計の語と金額のあいだに書いてよいもの: 空白と、コロンか読点一つ。 */
+const isTotalGap = (gap: string): boolean => /^[:：、,，]?$/u.test(gap.trim());
+const OPENERS = "（(";
+const CLOSERS = "）)";
+const CLOSER = /[）)]/u;
+
+const centsOf = (amount: Amount): number => Math.round(amount.value * CENTS);
+
+const sumOf = (values: readonly number[]): number => values.reduce((sum, value) => sum + value, 0);
+
+/** 英字で始まる語は、英字の続き（subtotal の total）では語と読まない。 */
+const LATIN = /[A-Za-z0-9]/u;
+
+const occurrences = (lower: string, phrase: string): number[] =>
+  [...lower.matchAll(new RegExp(phrase.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&"), "gu"))].map((match) => match.index);
+
+/** 語の文の中の位置。重なるときは前から、同じ所から始まるなら長いほうを取る。大文字小文字は区別しない。 */
+export const phraseSpans = (text: string, start: number, phrases: readonly string[]): Span[] => {
+  const lower = text.toLowerCase();
+  const found = phrases
+    .map((phrase) => phrase.toLowerCase())
+    .filter((phrase) => phrase !== "")
+    .flatMap((phrase) =>
+      occurrences(lower, phrase)
+        .filter((at) => !(LATIN.test(phrase[0] ?? "") && LATIN.test(lower[at - 1] ?? "")))
+        .map((at) => ({ start: at, end: at + phrase.length })),
+    )
+    .toSorted((left, right) => left.start - right.start || right.end - left.end);
+  return found
+    .filter((span, index) => found.slice(0, index).every((before) => before.end <= span.start))
+    .map((span) => ({ start: start + span.start, end: start + span.end }));
+};
+
+/** 金額の前に書いた単位（$9,000 の $）を除いた、語と金額のあいだ。 */
+const gapBefore = (source: string, from: number, amount: Amount): string => {
+  const gap = source.slice(from, amount.offset);
+  const trimmed = gap.trimEnd();
+  return trimmed.endsWith(amount.unit) ? trimmed.slice(0, trimmed.length - amount.unit.length) : gap;
+};
+
+/** 合計の語に近いほうから続く、二つ以上の並び（後ろ寄せ: 合計の前の内訳、前寄せ: 合計の後ろの内訳）。 */
+const nearRuns = (parts: readonly number[], nearEnd: boolean): number[][] =>
+  parts.slice(MIN_PARTS - 1).map((_, index) => (nearEnd ? parts.slice(parts.length - MIN_PARTS - index) : parts.slice(0, MIN_PARTS + index)));
+
+/** 内訳の金額。前の金額（並びの始まり）からこの金額までに値引きの語があれば、負の数。 */
+const signedValues = (source: string, parts: readonly Amount[], from: number, discounts: readonly string[]): number[] =>
+  parts.map((part, index) => {
+    const start = parts[index - 1]?.end ?? from;
+    const discounted = phraseSpans(source.slice(start, part.offset), start, discounts).length > 0;
+    return discounted ? -centsOf(part) : centsOf(part);
+  });
+
+type Breakdown = { readonly total: Amount; readonly parts: readonly Amount[]; readonly from: number; readonly nearEnd: boolean };
+
+const mismatch = (source: string, breakdown: Breakdown, discounts: readonly string[]): StructureIssue[] => {
+  const { total, from, nearEnd } = breakdown;
+  const parts = breakdown.parts.filter((part) => part.unit === total.unit);
+  if (parts.length < MIN_PARTS) return [];
+  const values = signedValues(source, parts, from, discounts);
+  const written = centsOf(total);
+  if (nearRuns(values, nearEnd).some((run) => sumOf(run) === written)) return [];
+  return [{ offset: total.offset, values: shownTotal(source, total, sumOf(values)) }];
+};
+
+/** 内訳の語が括弧の中にあれば、その括弧の終わり。無ければ文の終わり。 */
+const breakdownEnd = (source: string, total: Amount, marker: Span, sentence: Span): number => {
+  const between = source.slice(total.end, marker.start);
+  const opened = [...between].filter((char) => OPENERS.includes(char)).length > [...between].filter((char) => CLOSERS.includes(char)).length;
+  if (!opened) return sentence.end;
+  const close = CLOSER.exec(source.slice(marker.end, sentence.end));
+  return close === null ? sentence.end : marker.end + close.index;
+};
+
+const inside = (amounts: readonly Amount[], start: number, end: number): Amount[] => amounts.filter((amount) => amount.offset >= start && amount.end <= end);
+
+/** 合計の語のすぐ後ろの金額を、その前の内訳と比べる。内訳は、前の合計の語か内訳の語より後ろから。 */
+const totalsAfterParts = (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 breakdowns = phraseSpans(text, sentence.start, words.breakdowns);
+  return markers.flatMap((marker, index) => {
+    const total = amounts.find((amount) => amount.offset >= marker.end && isTotalGap(gapBefore(source, marker.end, amount)));
+    if (total === undefined) return [];
+    const from = Math.max(sentence.start, markers[index - 1]?.end ?? 0, ...breakdowns.filter((span) => span.end <= marker.start).map((span) => span.end));
+    return mismatch(source, { total, parts: inside(amounts, from, marker.start), from, nearEnd: true }, words.discounts);
+  });
+};
+
+/** 内訳の語のすぐ前の金額を合計とし、内訳の語の後ろ（括弧の中なら括弧の終わりまで、次の合計の語まで）の金額と比べる。 */
+const totalsBeforeParts = (source: string, sentence: Span, amounts: readonly Amount[], words: TotalWords): StructureIssue[] => {
+  const text = source.slice(sentence.start, sentence.end);
+  const totalMarkers = phraseSpans(text, sentence.start, words.totals);
+  return phraseSpans(text, sentence.start, words.breakdowns).flatMap((marker) => {
+    const total = amounts.findLast((amount) => amount.end <= marker.start);
+    if (total === undefined || phraseSpans(source.slice(total.end, marker.start), total.end, words.joiners).length > 0) return [];
+    const nextTotal = totalMarkers.find((span) => span.start >= marker.end)?.start ?? sentence.end;
+    const parts = inside(amounts, marker.end, Math.min(nextTotal, breakdownEnd(source, total, marker, sentence)));
+    return mismatch(source, { total, parts, from: marker.end, nearEnd: false }, words.discounts);
+  });
+};
+
+/** 文ごとに、書いた合計が内訳の和と合わない所。一つの金額は一度だけ言う。 */
+export const proseTotalMismatches = (source: string, sentences: readonly Span[], amounts: readonly Amount[], words: TotalWords): StructureIssue[] => {
+  const issues = 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 issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
+};

package/src/structure/reference-text.ts

@@ -54,11 +54,24 @@ const nameAfter = (source: string, end: number): { name: string; at: number } |
 /** 項や号の札（(a)、(ii)、（イ））。名前ではなく、参照の続き。 */
 const ITEM_LABEL = /^(?:[a-z]{1,2}|[ivxlcdm]{1,5}|.)$/iu;
 
+const LATIN_ASIDE = /^[\p{Script=Latin}\s.]+$/u;
+
+/**
+ * The name holds the aside. An English aside is a whole word or phrase: "or" in "Return of Information" is not the aside
+ * "or". Other asides are found anywhere (上記 in 上記参照).
+ */
+export const holdsAside = (name: string, aside: string): boolean => {
+  if (aside.trim() === "") return false;
+  if (!LATIN_ASIDE.test(aside)) return normalized(name).includes(normalized(aside));
+  const words = ` ${name
+    .normalize("NFKC")
+    .toLowerCase()
+    .replaceAll(/[^\p{L}\p{N}]+/gu, " ")} `;
+  return aside.trim() !== "" && words.includes(` ${aside.trim().toLowerCase()} `);
+};
+
 const isName = (name: string, words: ReferenceWords): boolean =>
-  LETTER.test(name) &&
-  !DIGIT.test(name) &&
-  !ITEM_LABEL.test(name.normalize("NFKC")) &&
-  !words.asides.some((aside) => normalized(name).includes(normalized(aside)));
+  LETTER.test(name) && !DIGIT.test(name) && !ITEM_LABEL.test(name.normalize("NFKC")) && !words.asides.some((aside) => holdsAside(name, aside));
 
 const agrees = (name: string, heading: string): boolean => {
   const [a, b] = [normalized(name), normalized(heading)];

package/src/structure/term-prefix.ts

@@ -0,0 +1,54 @@
+import type { BodyText } from "./definition-use.ts";
+
+/**
+ * 定義した語の頭の語（本・本件）を、同じ組のほかの語に替えた形。「本業務」と定義して「本件業務」と書くと、
+ * 読み手は別のものを指しているのかと迷う。組は言語パッケージの語彙表（defined-term-prefix）の group から取る。
+ */
+export type PrefixGroups = readonly (readonly string[])[];
+
+/** 語の前後の一字がこれなら、語は長い語の一部（見本物品の「本物品」、本業務委託契約の「本業務」）。 */
+const WORD_CHAR = /[\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}ー]/u;
+
+/** 頭の語のあとがこれより短い語（本件人、本件日）を替えると、普通の語（本人、本日）になる。 */
+const MIN_REST = 2;
+
+/** 語彙表の項目を group ごとにまとめる。group の無い項目と、一つしかない組は外す。 */
+export const prefixGroupsOf = (entries: readonly { readonly pattern: string; readonly group?: string | undefined }[]): string[][] => {
+  const groups = new Map<string, string[]>();
+  entries.forEach((entry) => {
+    if (entry.group === undefined || entry.pattern === "") return;
+    groups.set(entry.group, [...(groups.get(entry.group) ?? []), entry.pattern]);
+  });
+  return [...groups.values()].filter((group) => group.length > 1);
+};
+
+/** 語の頭の語を同じ組のほかの語に替えた形。頭の語は長いほうから当て、頭の語のあとが一字の語には形が無い。 */
+export const prefixVariants = (term: string, groups: PrefixGroups): string[] =>
+  groups.flatMap((group) => {
+    const prefix = group
+      .filter((candidate) => term.startsWith(candidate) && term.length > candidate.length)
+      .toSorted((left, right) => right.length - left.length)[0];
+    const rest = prefix === undefined ? "" : term.slice(prefix.length);
+    if (prefix === undefined || [...rest].length < MIN_REST) return [];
+    return group.filter((other) => other !== prefix).map((other) => `${other}${rest}`);
+  });
+
+/**
+ * 定義の後ろ（after より後）で、形の違う語を書いた位置。長い語の一部と、定義した語の始まり（本件物品明細と定義した所の本件物品）は除く。
+ */
+export const variantUses = (source: string, texts: readonly BodyText[], variant: string, after: number, defined: readonly string[]): number[] =>
+  texts.flatMap((text) => {
+    const offsets: number[] = [];
+    let at = text.text.indexOf(variant);
+    while (at !== -1) {
+      offsets.push(text.start + at);
+      at = text.text.indexOf(variant, at + variant.length);
+    }
+    return offsets.filter(
+      (offset) =>
+        offset > after &&
+        !WORD_CHAR.test(source.charAt(offset - 1)) &&
+        !WORD_CHAR.test(source.charAt(offset + variant.length)) &&
+        !defined.some((term) => source.startsWith(term, offset)),
+    );
+  });

package/src/structure/total.ts

@@ -154,6 +154,10 @@ const shownAmounts = (source: string, total: Placed, sumCents: number): Record<s
   return { written, sum: `${sumSign}${sum}${written.endsWith(total.unit) ? total.unit : ""}` };
 };
 
+/** 文の中の合計の金額（符号の無い、単位付きの金額）と和を、合計の書き方で見せる。 */
+export const shownTotal = (source: string, total: Amount, sumCents: number): Record<string, string> =>
+  shownAmounts(source, { ...total, column: 0, cents: Math.round(total.value * CENTS) }, sumCents);
+
 /**
  * 数だけの列で、合計の行の数が項目のどれかより大きくなければ、和ではなく平均や率や年の列と読んで足さない。
  * 項目に負の数があれば、和が項目より小さいこともあるので足す。

package/src/structure-shape/baseline-load.ts

@@ -1,14 +1,13 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { parse } from "yaml";
+import { PACKAGE_DIR, readText } from "../package-files.ts";
 import { parseStructureBaseline, type StructureBaseline } from "./baseline.ts";
 
-const BASELINE_FILE = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "structure-baseline.yaml");
+const BASELINE_FILE = join(PACKAGE_DIR, "structure-baseline.yaml");
 
 const readBaseline = (): StructureBaseline => {
   try {
-    return parseStructureBaseline(parse(readFileSync(BASELINE_FILE, "utf8")));
+    return parseStructureBaseline(parse(readText(BASELINE_FILE)));
   } catch (error) {
     throw new Error(`cannot read the structure baseline ${BASELINE_FILE}`, { cause: error });
   }

package/src/style-load.ts

@@ -1,16 +1,15 @@
-import { readFileSync, readdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { parse } from "yaml";
+import { PACKAGE_DIR, readDir, readText } from "./package-files.ts";
 import { parseStyle, type StyleDefinition } from "./style-parse.ts";
 
-const STYLES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "styles");
+const STYLES_DIR = join(PACKAGE_DIR, "styles");
 
 const loaded: { value: readonly StyleDefinition[] | undefined } = { value: undefined };
 
 const readStyle = (dir: string, file: string): StyleDefinition => {
   try {
-    return parseStyle(parse(readFileSync(join(dir, file), "utf8")), file);
+    return parseStyle(parse(readText(join(dir, file))), file);
   } catch (error) {
     throw new Error(`cannot read ${join(dir, file)}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }
@@ -19,7 +18,7 @@ const readStyle = (dir: string, file: string): StyleDefinition => {
 /** The bundled house styles (styles/*.yaml), by file name. Read once. */
 export const loadStyles = (dir: string = STYLES_DIR): readonly StyleDefinition[] => {
   if (dir === STYLES_DIR && loaded.value !== undefined) return loaded.value;
-  const styles = readdirSync(dir)
+  const styles = readDir(dir)
     .filter((file) => file.endsWith(".yaml"))
     .toSorted((left, right) => left.localeCompare(right, "en"))
     .map((file) => readStyle(dir, file));