chaffjs 0.25.0 → 0.27.0

package/src/structure/percent-sum-prose.ts

@@ -0,0 +1,54 @@
+// A breakdown written in one sentence (「構成比は、Aが50%、Bが30%、Cが20%」, "By product, A made up 50% of sales, B 30% and
+// C 20%") whose shares do not add up to 100%. The table and list form is structure/percent-sum.ts; the words are the same.
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import type { Amount } from "./total.ts";
+import type { ShareWords } from "./percent-sum.ts";
+
+const WHOLE = 100;
+/** A sentence names two shares in passing (「AとBで50%」); a breakdown in prose names at least three parts. */
+const MIN_PARTS = 3;
+/**
+ * How far from 100% a sentence may add up and still read as one whole broken down. Far below it, the sentence names only the
+ * larger parts (「Aが50%、Bが20%、Cが10%など」); far above it, the percentages are of different wholes ("55% of directors,
+ * 48% of managers") or of two periods ("45% (40% last year)"), or the total is among them (「合計100%」).
+ */
+const BAND = 10;
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+const DECIMALS = /\.(\d+)/u;
+/** A sign before the number (+3%, ▲2%): a change, not a part. */
+const SIGNS = "-+−▲△";
+
+const includesAny = (text: string, words: readonly string[]): boolean => {
+  const lowered = text.toLowerCase();
+  return words.some((word) => lowered.includes(word.toLowerCase()));
+};
+
+const decimalsOf = (source: string, amount: Amount): number => DECIMALS.exec(source.slice(amount.offset, amount.end))?.[1]?.length ?? 0;
+
+const isSigned = (source: string, amount: Amount): boolean => SIGNS.includes(source.slice(0, amount.offset).trimEnd().at(-1) ?? " ");
+
+/** The rounding the parts allow: half the last digit each, at least one point. */
+const toleranceOf = (source: string, shares: readonly Amount[]): number =>
+  Math.max(1, shares.length * HALF * DECIMAL_BASE ** -Math.max(0, ...shares.map((share) => decimalsOf(source, share))));
+
+const isBroken = (sum: number, tolerance: number): boolean => Math.abs(sum - WHOLE) > tolerance && Math.abs(sum - WHOLE) <= BAND;
+
+const issueIn = (source: string, sentence: Span, percents: readonly Amount[], words: ShareWords): StructureIssue[] => {
+  const text = source.slice(sentence.start, sentence.end);
+  if (!includesAny(text, words.labels) || includesAny(text, words.exceptions)) return [];
+  const shares = percents.filter((amount) => amount.offset >= sentence.start && amount.end <= sentence.end);
+  if (shares.length < MIN_PARTS || shares.some((share) => isSigned(source, share))) return [];
+  const sum = shares.reduce((total, share) => total + share.value, 0);
+  const decimals = Math.max(0, ...shares.map((share) => decimalsOf(source, share)));
+  if (!isBroken(sum, toleranceOf(source, shares))) return [];
+  return [{ offset: shares[0]?.offset ?? sentence.start, values: { sum: `${sum.toFixed(decimals)}${shares[0]?.unit ?? ""}` } }];
+};
+
+/** Each sentence that names a share word and three or more unsigned percentages whose sum misses 100% by more than rounding, and by no more than BAND. */
+export const proseShareMismatches = (source: string, sentences: readonly Span[], amounts: readonly Amount[], words: ShareWords): StructureIssue[] => {
+  if (words.labels.length === 0) return [];
+  const percents = amounts.filter((amount) => words.units.includes(amount.unit));
+  return sentences.flatMap((sentence) => issueIn(source, sentence, percents, words));
+};

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/version-mismatch.ts

@@ -0,0 +1,103 @@
+// A version written in the lead-in to a code block ("Install version 2.3.0 from npm:") that the block itself does not
+// show (npm install tidyq@2.4.0). Pure: reads the source, the code blocks, and the prose with code covered.
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * A dotted version of three parts (2.4.0, v1.12.3, 3.0.0-beta.2). Two parts (22.04, 3.1) are too often a decimal, and a
+ * first part of four digits is too often a date (2024.01.15).
+ */
+const VERSION = /(?<![\w.])v?(\d{1,3}\.\d{1,4}\.\d{1,4}(?:-[0-9A-Za-z.]+)?)(?![\w.]|\.\d)/gu;
+
+/** A word that makes a version a bound or a starting point, not the version installed: 「2.3.0 から」 "from 2.3.0", "20.0.0 or later". */
+export type RangeWord = { readonly word: string; readonly position: "before" | "after" };
+
+/** What tells which versions are the block's: the bound words, and the Latin words that lead to the version installed. */
+export type VersionWords = { readonly ranges: readonly RangeWord[]; readonly versionWords: readonly string[] };
+
+/** One code block: where it starts and the text between its fences. */
+export type CodeBlock = { readonly start: number; readonly code: string };
+
+/** How far a range word may stand from the version (a space, a "v"). */
+const RANGE_GAP = 2;
+
+type Found = { readonly start: number; readonly end: number; readonly version: string };
+
+const versionsIn = (text: string, offset = 0): Found[] =>
+  [...text.matchAll(VERSION)].map((match) => ({ start: offset + match.index, end: offset + match.index + match[0].length, version: match[1] ?? "" }));
+
+const isBound = (prose: string, found: Span, words: readonly RangeWord[]): boolean =>
+  words.some(({ word, position }) => {
+    if (word === "") return false;
+    const near =
+      position === "after"
+        ? prose.slice(found.end, found.end + RANGE_GAP + word.length)
+        : prose.slice(Math.max(0, found.start - RANGE_GAP - word.length), found.start);
+    return near.toLowerCase().includes(word.toLowerCase());
+  });
+
+/** The names a block pins its version to: tidyq in tidyq@2.4.0, tidyq==2.4.0, tidyq=2.4.0, tidyq:2.4.0, "tidyq": "2.4.0". */
+const PINNED = /^([\w.-]+)(?:@|==|=|:)[v^~]?\d/u;
+const QUOTES = /["']/gu;
+const OPENS_WITH_NUMBER = /^[v^~]?\d/u;
+
+/** Each whitespace-separated word of the code, quotes dropped; "tidyq": "2.4.0" is read as tidyq:2.4.0. */
+const codeWords = (code: string): string[] => {
+  const words = code.split(/\s+/u).map((word) => word.replaceAll(QUOTES, "").replace(/,$/u, ""));
+  return words.map((word, index) => (word.endsWith(":") && OPENS_WITH_NUMBER.test(words[index + 1] ?? "") ? `${word}${words[index + 1] ?? ""}` : word));
+};
+
+const pinnedNames = (code: string): Set<string> => new Set(codeWords(code).flatMap((word) => PINNED.exec(word)?.[1]?.toLowerCase() ?? []));
+
+const LATIN = /^[A-Za-z]/u;
+const WORD_CHAR = /[\w.+-]/u;
+/** How far back the word before a version is looked for. */
+const WORD_REACH = 40;
+
+/** The Latin word right before a position, if the word there is Latin: "Node.js" in "Requires Node.js 18.17.0". */
+const latinWordBefore = (text: string): string | undefined => {
+  const last = [...(text.trimEnd().split(/\s/u).at(-1) ?? "")];
+  const word = last.slice(0, last.findLastIndex((char) => WORD_CHAR.test(char)) + 1).join("");
+  return LATIN.test(word) ? word.toLowerCase() : undefined;
+};
+
+/**
+ * Whether a lead-in version is about the block's software. A Latin word right before it must be one of the words that lead
+ * to the version installed (version, release, install; lexicon version-lead) or the pinned software: "Requires Node.js
+ * 18.17.0" over `npm install pkg@2.4.0` names another program. A version after no Latin word (「npm から 2.3.0」) is the block's.
+ */
+const isAboutBlock = (prose: string, found: Found, names: ReadonlySet<string>, versionWords: readonly string[]): boolean => {
+  const word = latinWordBefore(prose.slice(Math.max(0, found.start - WORD_REACH), found.start));
+  return word === undefined || names.has(word) || versionWords.some((name) => name.toLowerCase() === word);
+};
+
+const BLANK_LINE = /\r?\n[ \t]*\r?\n/gu;
+const NOT_PROSE = /^\s*(?:#|[-*+]\s|\d{1,3}[.)]\s|```|~~~|\|)/u;
+const LETTER = /\p{L}/u;
+
+/** The paragraph right above a code block: the lines up to the blank line before it. A heading, a list item, a table or a bare version above is not a lead-in. */
+const leadInOf = (source: string, blockStart: number): Span | undefined => {
+  const lines = source.slice(0, blockStart).trimEnd();
+  const last = [...lines.matchAll(BLANK_LINE)].at(-1);
+  const start = last === undefined ? 0 : last.index + last[0].length;
+  const text = lines.slice(start);
+  const words = text.replace(VERSION, "");
+  return text === "" || NOT_PROSE.test(text) || !LETTER.test(words) ? undefined : { start, end: lines.length };
+};
+
+/**
+ * Each version in a code block's lead-in that differs from the one version the block shows. A block with no version, or
+ * with two (an upgrade from one to the other), says nothing to compare; a version marked as a bound, or named after another
+ * program, is not the one installed.
+ */
+export const versionMismatches = (source: string, prose: string, blocks: readonly CodeBlock[], words: VersionWords): StructureIssue[] =>
+  blocks.flatMap((block) => {
+    const shown = [...new Set(versionsIn(block.code).map((found) => found.version))];
+    const leadIn = leadInOf(source, block.start);
+    const [code] = shown;
+    if (shown.length !== 1 || code === undefined || leadIn === undefined) return [];
+    const names = pinnedNames(block.code);
+    return versionsIn(prose.slice(leadIn.start, leadIn.end), leadIn.start)
+      .filter((found) => found.version !== code && !isBound(prose, found, words.ranges) && isAboutBlock(prose, found, names, words.versionWords))
+      .map((found) => ({ offset: found.start, values: { written: found.version, code } }));
+  });

package/src/structure/weekday.ts

@@ -5,6 +5,7 @@ import { inDocumentOrder } from "./issues.ts";
 // 日付と、その横に書いた曜日の食い違い。暦で決まるので、両方読めれば誤りは機械で言える。
 
 const FULL_DATE = /^(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})$/u;
+const MONTH_DAY = /^(?<m>\d{2})-(?<d>\d{2})$/u;
 
 /** 暦の曜日。日曜日が 0。存在しない日（2月30日）は undefined。 */
 export const weekdayOf = (value: string): number | undefined => {
@@ -15,11 +16,87 @@ export const weekdayOf = (value: string): number | undefined => {
   return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day ? date.getUTCDay() : undefined;
 };
 
-/** 年まで書いた日付で、書いた曜日が暦と違うもの。年の無い日付は曜日を決められないので見ない。 */
-export const weekdayMismatches = (tree: StructureNode): StructureIssue[] =>
-  inDocumentOrder(tree).flatMap((node) => {
+const DAY_MS = 86_400_000;
+/** 年を書いた日付から 5 か月以内なら、前後の年のどれか一つだけがそこに収まる。半年を超えると、どちらの年とも読める。 */
+const YEAR_REACH_DAYS = 153;
+
+const timeOf = (value: string): number | undefined => {
+  const groups = FULL_DATE.exec(value)?.groups;
+  return groups === undefined || weekdayOf(value) === undefined ? undefined : Date.UTC(Number(groups["y"]), Number(groups["m"]) - 1, Number(groups["d"]));
+};
+
+/**
+ * 年の無い月日（「10-09」）に、年を書いた日付（anchor、「2026-10-06」）の前後の年のうち、anchor から 5 か月以内に収まる年を付ける。
+ * メールや議事録は、文書の日付の年を書いて、そのあとの日付の年を省く。12月の文書の「1月5日」は翌年。どの年も収まらなければ undefined。
+ */
+export const withNearestYear = (monthDay: string, anchor: string): string | undefined => {
+  const groups = MONTH_DAY.exec(monthDay)?.groups;
+  const anchorYear = FULL_DATE.exec(anchor)?.groups?.["y"];
+  const anchorTime = timeOf(anchor);
+  if (groups === undefined || anchorYear === undefined || anchorTime === undefined) return undefined;
+  return [-1, 0, 1]
+    .map((offset) => `${String(Number(anchorYear) + offset)}-${groups["m"] ?? ""}-${groups["d"] ?? ""}`)
+    .find((candidate) => {
+      const time = timeOf(candidate);
+      return time !== undefined && Math.abs(time - anchorTime) <= YEAR_REACH_DAYS * DAY_MS;
+    });
+};
+
+/**
+ * 年の無い日付の年を決める手がかり。stamp は文書の日付（「更新日：」の段落など）、sectionStarts は見出しで分けた節の始まり、
+ * yearHeadings はそのうち見出しが年を名指す節（「## 2024年度」）の始まり。anchorable は、年を決めるのに使ってよい日付か
+ * （引用符で日付だけを挙げた例は使わない）。
+ */
+export type YearContext = {
+  readonly stamp?: string | undefined;
+  readonly sectionStarts: readonly number[];
+  readonly yearHeadings?: readonly number[];
+  readonly anchorable?: (node: StructureNode) => boolean;
+};
+
+const sectionOf = (starts: readonly number[], offset: number): number => starts.filter((start) => start <= offset).length;
+
+/** 文書の書き出し: 最初の見出しより前と、最初の見出しの節。メールや議事録の頭の日付（日付：、日時：）が書かれる所。 */
+const OPENING_SECTIONS = 1;
+
+/**
+ * 年の無い日付の年を決める、年を書いた日付。同じ節のすぐ前のもの（前に無ければ後ろの最初のもの）。節に無ければ文書の日付、
+ * それも無ければ書き出しの最初の日付。年度ごとの見出しの下の「1月24日（火）」はその節の年で読み、別の節の日付の年では読まない。
+ */
+const anchorOf = (dated: readonly StructureNode[], node: StructureNode, context: YearContext): string | undefined => {
+  const section = sectionOf(context.sectionStarts, node.span.start);
+  const inSection = dated.filter((other) => sectionOf(context.sectionStarts, other.span.start) === section);
+  const nearest = inSection.findLast((other) => other.span.start < node.span.start) ?? inSection[0];
+  // 見出しが年を名指す節（「## 2024年度」）の日付は、その年の中にある。節の外の日付からは決めない。
+  const sectionStart = context.sectionStarts[section - 1];
+  if (nearest === undefined && sectionStart !== undefined && (context.yearHeadings ?? []).includes(sectionStart)) return undefined;
+  const opening = dated.find((other) => sectionOf(context.sectionStarts, other.span.start) <= OPENING_SECTIONS);
+  const stamp = context.stamp !== undefined && FULL_DATE.test(context.stamp) ? context.stamp : undefined;
+  const fromTree = (found: StructureNode | undefined): string | undefined => (found === undefined ? undefined : String(found.attrs["value"]));
+  return fromTree(nearest) ?? stamp ?? fromTree(opening);
+};
+
+/** 日付の年月日。年の無い日付は、近くの年を書いた日付から年を決めて付ける。決まらなければ undefined。 */
+const fullValueOf = (dated: readonly StructureNode[], node: StructureNode, context: YearContext): string | undefined => {
+  const value = String(node.attrs["value"]);
+  if (!MONTH_DAY.test(value)) return value;
+  const anchor = anchorOf(dated, node, context);
+  return anchor === undefined ? undefined : withNearestYear(value, anchor);
+};
+
+/**
+ * 書いた曜日が暦と違う日付。年の無い日付は、年を書いた日付（anchorOf）から 5 か月以内に収まる年として比べる。
+ * 年を書いた日付が文書に無いか、どの年も収まらなければ、曜日を決められないので見ない。
+ */
+export const weekdayMismatches = (tree: StructureNode, context: YearContext = { sectionStarts: [] }): StructureIssue[] => {
+  const dates = inDocumentOrder(tree).filter((node) => node.kind === "date");
+  const anchorable = context.anchorable ?? (() => true);
+  const dated = dates.filter((node) => timeOf(String(node.attrs["value"])) !== undefined && anchorable(node));
+  return dates.flatMap((node) => {
     const written = node.attrs["weekday"];
-    if (node.kind !== "date" || typeof written !== "number") return [];
-    const actual = weekdayOf(String(node.attrs["value"]));
-    return actual === undefined || actual === written ? [] : [{ offset: node.span.start, values: { date: String(node.attrs["value"]), written, actual } }];
+    if (typeof written !== "number") return [];
+    const value = fullValueOf(dated, node, context);
+    const actual = value === undefined ? undefined : weekdayOf(value);
+    return value === undefined || actual === undefined || actual === written ? [] : [{ offset: node.span.start, values: { date: value, written, actual } }];
   });
+};

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));