chaffjs 0.32.0 → 0.34.0

package/src/company-names.ts

@@ -1,5 +1,6 @@
 import { nameKey } from "./name-variants.ts";
 import { escapeRegExp } from "./orthography.ts";
+import { isNameEndingSlip } from "./company-name-ending.ts";
 
 // 会社の名前を、文書の中で二通りに書いた所（株式会社アオバシステム と アオバシステム株式会社、Aoba Systems Inc. と Aoba Systems Ltd.）。
 // 会社の形の語（株式会社、Inc）は語彙表 company-form が言う。group が同じ語は同じ形（Inc と Incorporated、株式会社 と (株)）、
@@ -27,8 +28,11 @@ export type CompanyMention = {
   readonly foreign?: boolean | undefined;
 };
 
-/** 二つの書き方の違い。spelling は記号・幅・大小だけ、form は会社の形、position は形の語の側、near は名前の一字違い。 */
-type CompanyRelation = "spelling" | "form" | "position" | "near";
+/**
+ * 二つの書き方の違い。spelling は記号・幅・大小だけ、form は会社の形、position は形の語の側、near は名前の一字違い、ending は
+ * 名前の一語の終わりだけの違い（company-name-ending.ts）。
+ */
+type CompanyRelation = "spelling" | "form" | "position" | "near" | "ending";
 
 type CompanyVariant = { readonly mention: CompanyMention; readonly usual: string; readonly kind: CompanyRelation };
 
@@ -82,6 +86,18 @@ const SPACES: ReadonlySet<string> = new Set([" ", "\u3000"]);
  */
 export type KanaStops = { readonly particles: readonly string[]; readonly openers: readonly string[]; readonly ends: readonly string[] };
 
+/**
+ * 品詞解析が形容詞・動詞・助動詞と読んだ語の終わり（source の上の位置）。い で終わるひらがな（ながい、しおさい）は、ここで終わる
+ * なら名前の頭と読まない（ながい食品 の ながい）。名前の頭の い（しおさい の さい）は名詞と読まれる。
+ */
+export type PredicateEnds = ReadonlySet<number>;
+
+const NO_PREDICATE_ENDS: PredicateEnds = new Set();
+const PREDICATE_TAIL = "い";
+
+/** い で終わる名前の頭が、品詞解析の形容詞・動詞・助動詞の終わりか（ながい食品 の ながい）。 */
+const isPredicateHead = (head: string, end: number, predicateEnds: PredicateEnds): boolean => head.endsWith(PREDICATE_TAIL) && predicateEnds.has(end);
+
 /** ひらがなの前に何があるか。word は語や閉じ括弧（当社はこもれび、）により）、form は会社の形の語（株式会社こもれび）、boundary は句読点や行の頭。 */
 export type KanaLead = "word" | "form" | "boundary";
 
@@ -117,26 +133,27 @@ const kanaRunStart = (source: string, end: number): number => {
 };
 
 /** 名前の前に続くひらがなのうち、名前の頭と読む所を足した始まり。 */
-const withKanaHead = (source: string, start: number, stops: KanaStops): number => {
+const withKanaHead = (source: string, start: number, stops: KanaStops, predicateEnds: PredicateEnds): number => {
   const kanaStart = kanaRunStart(source, start);
   if (kanaStart === start) return start;
   const lead = GLUED.test(source.charAt(kanaStart - 1)) ? "word" : "boundary";
-  return start - (kanaHeadOf(source.slice(kanaStart, start), lead, stops)?.length ?? 0);
+  const head = kanaHeadOf(source.slice(kanaStart, start), lead, stops);
+  return head === undefined || isPredicateHead(head, start, predicateEnds) ? start : start - head.length;
 };
 
 /** 漢字・かなの名前: 形の語の隣の、名前に使う字の続き。形の語との間の空白一つは名前の外。 */
-const cjkBaseBefore = (source: string, end: number, stops: KanaStops): Span | undefined => {
+const cjkBaseBefore = (source: string, end: number, stops: KanaStops, predicateEnds: PredicateEnds): Span | undefined => {
   const stop = SPACES.has(source.charAt(end - 1)) ? end - 1 : end;
   const match = CJK_BEFORE.exec(source.slice(0, stop));
-  return match === null ? undefined : { start: withKanaHead(source, match.index, stops), end: stop };
+  return match === null ? undefined : { start: withKanaHead(source, match.index, stops, predicateEnds), end: stop };
 };
 
 /** 形の語の後ろの名前。ひらがなで始まる名前（株式会社こもれび珈琲）は、ひらがなの後ろに名前に使う字が続くときだけ。 */
-const cjkBaseAfter = (source: string, start: number, stops: KanaStops): Span | undefined => {
+const cjkBaseAfter = (source: string, start: number, stops: KanaStops, predicateEnds: PredicateEnds): Span | undefined => {
   const from = SPACES.has(source.charAt(start)) ? start + 1 : start;
   const kana = KANA_AFTER.exec(source.slice(from))?.[0] ?? "";
   const head = kana === "" ? "" : kanaHeadOf(kana, "form", stops);
-  if (head === undefined) return undefined;
+  if (head === undefined || isPredicateHead(head, from + head.length, predicateEnds)) return undefined;
   const match = CJK_AFTER.exec(source.slice(from + head.length));
   return match === null ? undefined : { start: from, end: from + head.length + match[0].length };
 };
@@ -184,23 +201,36 @@ const foreignMentionAt = (source: string, form: CompanyForm, at: number, words:
   return { ...mentionOf(source, base, { start: at, end: at + form.pattern.length }, form.group), foreign: true };
 };
 
-const baseBefore = (source: string, at: number, latin: boolean, isProper: IsProper, stops: KanaStops): Span | undefined =>
-  latin ? latinBaseBefore(source, at, isProper) : cjkBaseBefore(source, at, stops);
+const baseBefore = (source: string, at: number, latin: boolean, isProper: IsProper, stops: KanaStops, predicateEnds: PredicateEnds): Span | undefined =>
+  latin ? latinBaseBefore(source, at, isProper) : cjkBaseBefore(source, at, stops, predicateEnds);
 
 /** 形の語の一つの現れから、会社の名前の現れ。名前が前にあればそれを、無ければ後ろを取る。 */
-const mentionAt = (source: string, form: CompanyForm, at: number, isProper: IsProper, stops: KanaStops): CompanyMention | undefined => {
+const mentionAt = (
+  source: string,
+  form: CompanyForm,
+  at: number,
+  isProper: IsProper,
+  stops: KanaStops,
+  predicateEnds: PredicateEnds,
+): CompanyMention | undefined => {
   if (form.foreign !== undefined) return foreignMentionAt(source, form, at, form.foreign.words);
   const formSpan = { start: at, end: at + form.pattern.length };
   const latin = LATIN.test(form.pattern);
   if (latin && CONTINUED.test(source.slice(formSpan.end))) return undefined;
-  const before = form.position === "before" ? undefined : baseBefore(source, at, latin, isProper, stops);
+  const before = form.position === "before" ? undefined : baseBefore(source, at, latin, isProper, stops, predicateEnds);
   if (before !== undefined && isNameBase(source, before, isProper)) return mentionOf(source, before, formSpan, form.group);
-  const after = form.position === "after" || latin ? undefined : cjkBaseAfter(source, formSpan.end, stops);
+  const after = form.position === "after" || latin ? undefined : cjkBaseAfter(source, formSpan.end, stops, predicateEnds);
   return after !== undefined && isNameBase(source, after, isProper) ? mentionOf(source, after, formSpan, form.group) : undefined;
 };
 
 /** 文書の中の会社の名前の現れ。長い形の語（Co., Ltd）を先に取り、その中の短い語（Ltd）は数えない。 */
-export const companyMentionsIn = (source: string, forms: readonly CompanyForm[], isProper: IsProper, stops: KanaStops): CompanyMention[] => {
+export const companyMentionsIn = (
+  source: string,
+  forms: readonly CompanyForm[],
+  isProper: IsProper,
+  stops: KanaStops,
+  predicateEnds: PredicateEnds = NO_PREDICATE_ENDS,
+): CompanyMention[] => {
   const taken: Span[] = [];
   return forms
     .toSorted((left, right) => right.pattern.length - left.pattern.length)
@@ -209,7 +239,7 @@ export const companyMentionsIn = (source: string, forms: readonly CompanyForm[],
         const end = at + form.pattern.length;
         if (!standsAsWord(source, form.pattern, at) || taken.some((span) => span.start < end && at < span.end)) return [];
         taken.push({ start: at, end });
-        const mention = mentionAt(source, form, at, isProper, stops);
+        const mention = mentionAt(source, form, at, isProper, stops, predicateEnds);
         return mention === undefined ? [] : [mention];
       }),
     )
@@ -316,12 +346,17 @@ const talliesOf = (mentions: readonly CompanyMention[]): Tally[] => {
 /** 多いほうが先。同数なら先に書いたほう。 */
 const byUsage = (left: Tally, right: Tally): number => right.count - left.count || left.first.offset - right.first.offset;
 
-/** 短い名前のかなの一字違いは、別の会社のこともあるので、相手が二度以上、こちらが一度だけのときに限る。 */
+/**
+ * 短い名前のかなの一字違いと、名前の一語の終わりだけの違い（Brightmoor と Brightmore、Water Utility と Water Utilities）は、別の
+ * 会社のこともあるので、形も側も同じで、相手が二度以上、こちらが一度だけのときに限る。
+ */
 const relationBetween = (tally: Tally, other: Tally): CompanyRelation | undefined => {
   const relation = companyRelation(tally.first, other.first);
   if (relation !== undefined || tally.count !== 1 || other.count < 2) return relation;
   const [left, right] = [tally.first, other.first];
-  return left.form === right.form && left.position === right.position && isKanaWordSlip(nameKey(left.base), nameKey(right.base)) ? "near" : undefined;
+  if (left.form !== right.form || left.position !== right.position) return undefined;
+  if (isKanaWordSlip(nameKey(left.base), nameKey(right.base))) return "near";
+  return isNameEndingSlip(left.base, right.base) ? "ending" : undefined;
 };
 
 /** 同じ会社の、少ないほうの書き方。同じ会社と言える相手のうち一番多いものと比べる。書き方ごとに最初の現れを一つ。 */

package/src/cross-run.ts

@@ -40,6 +40,7 @@ const optionsFor = (input: CrossInput, rule: RuleDefinition): DetectorOptions =>
   lexicon: rule.word_list === undefined ? undefined : input.doc.lexicons[rule.word_list],
   where: rule.where,
   ...(rule.options === undefined ? {} : { settings: optionValues(settleOptions(rule.id, rule.options, input.context.optionLayers ?? [])) }),
+  genre: input.context.genre,
 });
 
 /** What one rule did to the documents taking part (by path): its findings, or why it did not run after all. */

package/src/custom/no-rewrite.ts

@@ -0,0 +1,2 @@
+/** The variant of a words rule's finding whose word-list entry has no rewrite, so there is no spelling to offer. */
+export const NO_REWRITE = "no-rewrite";

package/src/custom/parse.ts

@@ -5,6 +5,7 @@ import { modulePathOf, type ModulePathRefusal } from "./module-path.ts";
 import type { FieldProblem } from "../rule-fields.ts";
 import { failed, ok, type Checked } from "./checked.ts";
 import { describedOf, exampleSides, levelsOf, type Described, type RuleLevels } from "./dsl-fields.ts";
+import { NO_REWRITE } from "./no-rewrite.ts";
 
 // custom_rules in chaff.yaml: a team's own deterministic rules, written without code. Each becomes a RuleDefinition like the
 // built-in ones, so findings, explain, rules --json, stet, the baseline and SARIF treat it the same. Pure: the YAML comes in parsed.
@@ -198,13 +199,28 @@ const languagesOf = (raw: unknown, at: string): Checked<readonly string[] | unde
   return list.length > 0 && list.every(nonEmpty) ? ok(list.map((entry: string) => entry.trim())) : failed({ kind: "bad-languages", at });
 };
 
+/** The rule's name and what was found: the message for a finding with no spelling to use. */
+const namedMessage = (name: Localized): Localized =>
+  Object.fromEntries(Object.entries(name).map(([language, text]) => [language, language === "ja" ? `${text}:「{matched}」` : `${text}: "{matched}"`]));
+
 /** The message when a rule does not write one: the replacement for a word list, else the rule's name and what was found. */
 const defaultMessage = (spec: CustomSpec, name: Localized): Localized => {
   if (spec.type === "words" && spec.words.every((pair) => pair.use !== ""))
     return { ja: "「{matched}」は「{preferred}」と書きます", en: 'Write "{preferred}", not "{matched}"' };
-  return Object.fromEntries(Object.entries(name).map(([language, text]) => [language, language === "ja" ? `${text}:「{matched}」` : `${text}: "{matched}"`]));
+  return namedMessage(name);
+};
+
+/** In each language, the rule's own message unless it offers {preferred}, else the named message. */
+const noRewriteMessage = (written: Localized | undefined, name: Localized): Localized => {
+  const named = namedMessage(name);
+  if (written === undefined) return named;
+  return Object.fromEntries(Object.entries(written).map(([language, text]) => [language, text.includes("{preferred}") ? (named[language] ?? text) : text]));
 };
 
+/** A word-list entry may have no rewrite: that finding must not offer an empty spelling. */
+const defaultMessages = (spec: CustomSpec, written: Localized | undefined, name: Localized): Readonly<Record<string, Localized>> =>
+  spec.type === "words" ? { [NO_REWRITE]: noRewriteMessage(written, name) } : {};
+
 const PLACEHOLDERS: Readonly<Record<string, Localized>> = {
   matched: { ja: "見つけた語句", en: "the text found" },
   preferred: { ja: "使う書き方", en: "the spelling to use" },
@@ -249,7 +265,7 @@ const definitionOf = (id: string, raw: Record<string, unknown>, parts: Parts, us
   why: parts.texts.why,
   how_to_fix: parts.texts.how_to_fix,
   message: localizedOf(raw["message"]) ?? defaultMessage(parts.spec, parts.texts.name),
-  messages: {},
+  messages: defaultMessages(parts.spec, localizedOf(raw["message"]), parts.texts.name),
   placeholders: PLACEHOLDERS,
   levels: parts.levels.table,
   level_sets: "severity",

package/src/detectors/age-words.ts

@@ -0,0 +1,12 @@
+import type { ProseDocument } from "../plugin.ts";
+import type { AgeWord, AgeWords } from "../facts/age-values.ts";
+
+const ageWordsAt = (doc: ProseDocument, id: string): AgeWord[] =>
+  (doc.lexicons[id] ?? []).map((entry): AgeWord => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+/** 年齢の語: 印（fact-age-mark）、上限の印（fact-age-limit）、範囲をつなぐ語（fact-age-joiner）。 */
+export const ageWordsOf = (doc: ProseDocument): AgeWords => ({
+  marks: ageWordsAt(doc, "fact-age-mark"),
+  limits: ageWordsAt(doc, "fact-age-limit"),
+  joiners: (doc.lexicons["fact-age-joiner"] ?? []).map((entry) => entry.pattern),
+});

package/src/detectors/agreement-slip.ts

@@ -1,4 +1,5 @@
 import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+import { isPartOfAddress } from "./address-word.ts";
 import { isPartOfLongerWord } from "./doubled-word.ts";
 
 /**
@@ -130,6 +131,8 @@ const numberSlipAt = (source: string, tokens: readonly Token[], at: number, list
   const nounAt = at + determiner.length + modifiers.length;
   const noun = tokens[nounAt];
   if (!isCommonNoun(noun) || !hasOneNumber(noun, lists.invariant) || isPlural(noun) === determiner.plural) return undefined;
+  // A file name or a path (a quotes.json, a docs/ folder) is spelled as it must be, not counted.
+  if (isPartOfAddress(source, noun.span.start, noun.span.end)) return undefined;
   if (mayBeVerb(determiner, modifiers, noun, tokens[nounAt + 1], lists.finite)) return undefined;
   const span = tokens.slice(at, nounAt + 1);
   if (!endsNounPhrase(tokens[nounAt + 1], lists.finite) || !joinedBySpace(source, span) || isPartOfLongerWord(source, determiner.head, noun)) return undefined;

package/src/detectors/annual-pay-mismatch.ts

@@ -3,9 +3,8 @@
 // are annual-pay-label, the other words annual-pay-word, approximate-marker, duration-month, number-word (digit),
 // range-connector and amount-range-word.
 import type { Detector, Finding, Lexicon, ProseDocument } from "../plugin.ts";
-import { annualPayMismatches, type AnnualPayWords, type PayAmount, type PositionedWord } from "../structure/annual-pay.ts";
-import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
-import { amountsIn, formsOf } from "./currency-notation.ts";
+import { annualPayMismatches, type AnnualPayWords, type PositionedWord } from "../structure/annual-pay.ts";
+import { statedAmountsOf } from "./stated-amounts.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAround } from "./quote-around.ts";
 
@@ -44,23 +43,9 @@ const wordsOf = (doc: ProseDocument): AnnualPayWords => ({
   numberWords: numberWordsOf(doc),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): PayAmount[] => {
-  const scales = scaleWordsOf(doc);
-  return amountsIn(
-    text,
-    formsOf(doc),
-    scales.map((scale) => scale.word),
-  ).flatMap((amount) => {
-    const read = scaledAmountOf(text, amount, scales);
-    return read === undefined
-      ? []
-      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
-  });
-};
-
 export const annualPayMismatch: Detector = (doc): Finding[] => {
   const text = proseAndTablesOf(doc);
-  return annualPayMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+  return annualPayMismatches(text, statedAmountsOf(text, doc), wordsOf(doc)).map((issue) => ({
     rule: "annual-pay-mismatch",
     severity: "warning",
     line: 0,

package/src/detectors/blank-structure.ts

@@ -7,7 +7,7 @@ import { eachPreOrder, foldPostOrder } from "../tree-walk.ts";
 import { quoteAt } from "./structure-tree.ts";
 import { amountColumnOf, isTotalRowGap, type BodyRow } from "../structure/total-row-blank.ts";
 import { isAmountNameLine, isTotalLine } from "../structure/total-line.ts";
-import { isTotalLabel } from "../structure/total.ts";
+import { isTotalLabel, withoutLeadingBlankCells } from "../structure/total.ts";
 
 /** Fewer body rows than this, and one blank is as likely a choice as a gap. */
 const MIN_BODY_ROWS = 3;
@@ -178,7 +178,8 @@ const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexic
 
 /**
  * A total row starts with a total word (total-label, with total-label-qualifier or total-period-qualifier: Week total),
- * a tax word (tax-label), or is named by a computed amount (net-amount-label: Gross pay, Net pay).
+ * a tax word (tax-label), or is named by a computed amount (net-amount-label: Gross pay, Net pay). The word may sit in the
+ * first cell that is not blank (| | Total | $1,200 |): the cells before it are left blank on purpose.
  */
 const totalRowOf = (doc: ProseDocument): IsTotalRow => {
   const totals = {
@@ -188,7 +189,7 @@ const totalRowOf = (doc: ProseDocument): IsTotalRow => {
     amountNames: patternsOf(doc, "net-amount-label"),
   };
   const taxes = patternsOf(doc, "tax-label");
-  return (rowText) => isTotalLine(rowText, totals) || isAmountNameLine(rowText, totals) || isTotalLabel(rowText, taxes);
+  return (rowText) => isTotalLine(rowText, totals) || isAmountNameLine(rowText, totals) || isTotalLabel(withoutLeadingBlankCells(rowText), taxes);
 };
 
 export const emptyTableCell: Detector = findingsOf("empty-table-cell", (doc) => tableBlanks(doc.source, doc.replyQuotes ?? [], totalRowOf(doc)));

package/src/detectors/closing-balance-mismatch.ts

@@ -20,6 +20,7 @@ const wordsOf = (doc: ProseDocument): BalanceWords => ({
     outflow: patternsOf(doc, LEXICON, "outflow"),
     closing: patternsOf(doc, LEXICON, "closing"),
   },
+  asOf: patternsOf(doc, LEXICON, "as-of"),
   magnitudes: patternsOf(doc, "amount-multiplier"),
   percentUnits: patternsOf(doc, "percent-unit"),
 });

package/src/detectors/code-fences.ts

@@ -3,6 +3,7 @@
 import { parse } from "../markdown-read.ts";
 import { spanOf } from "../markdown-node.ts";
 import { eachPreOrder } from "../tree-walk.ts";
+import { maskSpans } from "../mask.ts";
 
 export type CodeFence = {
   /** Where the opening fence line starts. */
@@ -79,6 +80,15 @@ export const codeFences = (source: string): readonly CodeFence[] => {
   return fences;
 };
 
+/**
+ * The source with every fenced code block blanked, offsets and line breaks kept. A list or a sentence in a code block is an
+ * example, not the document's own: a rule that reads values from the source line by line reads this instead.
+ */
+export const withoutCodeBlocks = (source: string): string => {
+  const fences = codeFences(source);
+  return fences.length === 0 ? source : maskSpans(source, fences);
+};
+
 /** Inline code spans in a stretch of text: a run of backticks closed by a run of the same length. */
 export const codeSpans = (text: string, offset = 0): CodeSpan[] => {
   const spans: CodeSpan[] = [];

package/src/detectors/condition-toki.ts

@@ -0,0 +1,60 @@
+import type { Detector, Finding, Lexicon, Sentence, Token } from "../plugin.ts";
+import { isWithinAny, quotedIn } from "../quoted-span.ts";
+
+// A noun for a point in time written where the clause states a condition (認定を受けた時は → 認定を受けたときは). One word
+// list gives the noun and its kana form, another the particles that make the clause a condition; this file knows parts of
+// speech. Pure: the sentence and the word lists come in.
+
+export type ConditionWords = { readonly nouns: ReadonlyMap<string, string>; readonly followers: ReadonlySet<string> };
+
+export type ConditionSpelling = { readonly written: string; readonly preferred: string; readonly offset: number };
+
+/** A predicate ends the clause before the noun (受けた時, 過ぎる時, 支払わない時, 必要な時); の, その and ある (事故の時, その時) do not. */
+const PREDICATE_POS: ReadonlySet<string> = new Set(["VERB", "AUX", "ADJ"]);
+
+const FOLLOWER_LIST = "condition-follower";
+
+/** The nouns with their rewrite (時 → とき), and the particles that follow them in a condition (は, には, も). */
+export const conditionWordsOf = (nouns: Lexicon | undefined, followers: Lexicon | undefined): ConditionWords => ({
+  nouns: new Map((nouns ?? []).flatMap((entry): [string, string][] => (entry.rewrite === undefined ? [] : [[entry.pattern, entry.rewrite]]))),
+  followers: new Set((followers ?? []).map((entry) => entry.pattern)),
+});
+
+/** The follower right after index: one particle (は, も) or two the tagger splits (に + は). */
+const isFollowedByCondition = (tokens: readonly Token[], index: number, followers: ReadonlySet<string>): boolean => {
+  const next = tokens[index + 1]?.surface ?? "";
+  const pair = `${next}${tokens[index + 2]?.surface ?? ""}`;
+  return followers.has(next) || followers.has(pair);
+};
+
+const isConditionNoun = (tokens: readonly Token[], index: number, words: ConditionWords): boolean => {
+  const token = tokens[index];
+  if (token === undefined || !words.nouns.has(token.surface)) return false;
+  const previous = tokens[index - 1];
+  return previous !== undefined && PREDICATE_POS.has(previous.pos) && isFollowedByCondition(tokens, index, words.followers);
+};
+
+/** Each noun in the sentence, outside 「」『』, that ends a predicate and is followed by は, には or も. */
+export const conditionSpellingsIn = (sentence: Sentence, words: ConditionWords): ConditionSpelling[] => {
+  const tokens = sentence.tokens ?? [];
+  const quoted = quotedIn(sentence);
+  return tokens.flatMap((token, index) =>
+    isConditionNoun(tokens, index, words) && !isWithinAny(quoted, token.span)
+      ? [{ written: token.surface, preferred: words.nouns.get(token.surface) ?? "", offset: token.span.start }]
+      : [],
+  );
+};
+
+export const conditionToki: Detector = (doc, options): Finding[] => {
+  const words = conditionWordsOf(options.lexicon, doc.lexicons[FOLLOWER_LIST]);
+  return doc.sentences.flatMap((sentence) =>
+    conditionSpellingsIn(sentence, words).map((spelling) => ({
+      rule: "",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { matched: spelling.written, preferred: spelling.preferred, offset: spelling.offset },
+    })),
+  );
+};

package/src/detectors/conjugated-entry.ts

@@ -0,0 +1,53 @@
+import type { LexiconEntry, Sentence, Span, Token } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { entryRanges } from "./lexicon-match.ts";
+
+/**
+ * チームが辞書形の動詞で書いた語か（巻き取る・握っておく・utilize）。最後の語が動詞の原形のときだけ。
+ * 名詞（巻き取り・onboarding）や活用した形（握った）は書いた形のまま照らす。動詞の名詞形まで当てると、チームが並べていない語を指摘する。
+ */
+export const isDictionaryVerb = (entry: LexiconEntry): boolean => {
+  const last = entry.tokens?.at(-1);
+  return last?.pos === "VERB" && last.lemma?.toLowerCase() === last.surface.toLowerCase();
+};
+
+/** 直前に動詞が詰めて書いてある（受け|取ります）。そこは別の複合動詞の後ろ半分で、並べた動詞ではない。 */
+const tailOfCompound = (tokens: readonly Token[], start: number): boolean => {
+  const before = tokens[start - 1];
+  return before?.pos === "VERB" && before.span.end === tokens[start]?.span.start;
+};
+
+/**
+ * 辞書形の動詞で書いた語が、活用した形で文のどこに出たか（文の中の字の範囲）。複合動詞は語に割れる（巻き/取り）ので、語の並びで照らす。
+ * 品詞が無い文書、動詞でない語には何も返さない。字で探す側がそのまま当たる。
+ */
+export const conjugatedSpans = (sentence: Sentence, entry: LexiconEntry): Span[] => {
+  const tokens = sentence.tokens;
+  if (tokens === undefined || !isDictionaryVerb(entry)) return [];
+  return entryRanges(sentence, entry).flatMap((range) => {
+    const first = tokens[range.start];
+    const last = tokens[range.end - 1];
+    if (first === undefined || last === undefined || tailOfCompound(tokens, range.start)) return [];
+    return [{ start: first.span.start - sentence.span.start, end: last.span.end - sentence.span.start }];
+  });
+};
+
+const occurrencesOf = (text: string, word: string): Span[] =>
+  word === ""
+    ? []
+    : [...text.matchAll(new RegExp(escapeRegExp(word), "giu"))].map((match) => ({
+        start: match.index,
+        end: match.index + match[0].length,
+      }));
+
+/**
+ * prefer の「使わない書き方」が動詞のとき、活用した形の始まり（文の中の字の位置）。「使う書き方」の中に出たものは除く。
+ * 大文字小文字だけ違う組（Javascript・JavaScript）は語で照らすと区別が消えるので、字で探す側に任せる。
+ */
+export const conjugatedStartsOutside = (sentence: Sentence, entry: LexiconEntry, use: string): number[] => {
+  if (entry.pattern.toLowerCase() === use.toLowerCase()) return [];
+  const covered = occurrencesOf(sentence.text, use);
+  return conjugatedSpans(sentence, entry)
+    .filter((span) => !covered.some((cover) => cover.start <= span.start && span.end <= cover.end))
+    .map((span) => span.start);
+};

package/src/detectors/content-morphemes.ts

@@ -7,7 +7,8 @@ import type { Token } from "../plugin.ts";
 const CONTENT_POS = new Set(["NOUN", "PROPN", "NUM", "VERB", "ADJ", "ADV"]);
 
 /** 接頭詞・接尾・非自立の語（Bound）と、動詞にするだけの「する」（VerbType=Light）は、付いた語が中身を持つ。 */
-const isContent = (token: Token): boolean => CONTENT_POS.has(token.pos) && token.features?.["Bound"] !== "Yes" && token.features?.["VerbType"] !== "Light";
+export const isContent = (token: Token): boolean =>
+  CONTENT_POS.has(token.pos) && token.features?.["Bound"] !== "Yes" && token.features?.["VerbType"] !== "Light";
 
 /** 原形で照らす（変えました → 変える）。原形の無い語は書いた形で。 */
 const baseForm = (token: Token): string => (token.lemma ?? token.surface).toLowerCase();

package/src/detectors/cross-facts.ts

@@ -9,6 +9,7 @@ import { scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
 import { factsOutOfStep, writtenValue, type FactOutOfStep } from "../facts/cross-facts.ts";
 import { factWordsOf } from "./fact-consistency.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { perUnitsOf } from "./per-unit-words.ts";
 
 // cross-doc-fact-conflict reads facts as fact-conflict does (fact-consistency.ts), with two more kinds of value that a docs
 // site repeats from page to page: an email address and a version of three parts or more (2.4.1, v3).
@@ -32,7 +33,7 @@ const COLON_BEFORE = /[:：][\s*_]*$/u;
 const isEntry = (source: string, fact: Fact): boolean => COLON_BEFORE.test(source.slice(source.lastIndexOf("\n", fact.value.start - 1) + 1, fact.value.start));
 
 const factsOf = (doc: ProseDocument, tree: StructureNode): ScopedFact[] => {
-  const values = factValues(tree, doc.source, namedValues(doc));
+  const values = perUnitsOf(doc, factValues(tree, doc.source, namedValues(doc)));
   const entries = labelledFacts(doc.source, values, factWordsOf(doc)).filter((fact) => isEntry(doc.source, fact));
   return scopedFacts([...entries, ...tableFacts(doc.source, values)], tree, doc.source, summaryHeadings(doc));
 };

package/src/detectors/custom.ts

@@ -3,6 +3,8 @@ import { occurrencesOutside } from "../orthography.ts";
 import { tokenRuns } from "../custom/token-pattern.ts";
 import { joinedView, type JoinedView } from "../joined-view.ts";
 import { boundedMatches } from "../custom/bounded-match.ts";
+import { entriesForGenre } from "../lexicon-genres.ts";
+import { NO_REWRITE } from "../custom/no-rewrite.ts";
 
 // The detectors behind a team's custom_rules. Each reports every place it finds, at the rule's level; the spec comes from
 // the rule (DetectorOptions.custom). Positions are the document's, like every other finding.
@@ -18,6 +20,9 @@ const findingOf = (hit: Hit): Finding => ({
   values: { matched: hit.matched, preferred: hit.preferred, offset: hit.sentence.span.start + hit.offset },
 });
 
+/** A words finding: with no spelling to use (a word-list entry without rewrite), its rule's message for that. */
+const wordsFindingOf = (hit: Hit): Finding => ({ ...findingOf(hit), ...(hit.preferred === "" ? { variant: NO_REWRITE } : {}) });
+
 /**
  * The sentence with the line breaks that fall inside a word taken out (「関\nする」 reads 「関する」), so words and patterns
  * are found as the reader reads them. Positions found in it go back to the sentence's own.
@@ -48,7 +53,9 @@ const pairsOf = (
   spec: { readonly words: readonly { readonly avoid: string; readonly use: string }[] },
   options: DetectorOptions,
 ): readonly { avoid: string; use: string }[] =>
-  spec.words.length > 0 ? spec.words : (options.lexicon ?? []).map((entry) => ({ avoid: entry.pattern, use: entry.rewrite ?? "" }));
+  spec.words.length > 0
+    ? spec.words
+    : entriesForGenre(options.lexicon ?? [], options.genre).map((entry) => ({ avoid: entry.pattern, use: entry.rewrite ?? "" }));
 
 /** words: each spelling to avoid, outside the spelling to use (「ユーザ」 inside 「ユーザー」 is not reported). */
 export const customWords: Detector = (doc, options): Finding[] => {
@@ -58,7 +65,7 @@ export const customWords: Detector = (doc, options): Finding[] => {
   return doc.sentences.flatMap((sentence) => {
     const view = readAsWritten(sentence);
     return pairs.flatMap((pair) =>
-      occurrencesOutside(view.text, pair.avoid, pair.use).map((start) => findingOf(hitAt(sentence, view, start, start + pair.avoid.length, pair.use))),
+      occurrencesOutside(view.text, pair.avoid, pair.use).map((start) => wordsFindingOf(hitAt(sentence, view, start, start + pair.avoid.length, pair.use))),
     );
   });
 };

package/src/detectors/document-shape.ts

@@ -1,6 +1,7 @@
 // The shape of a document's top: whether the lead says anything the title does not, and whether a title or heading
 // runs too long to scan. Pure; both read only the sections, paragraphs and tokens chaff has already built.
 import { newContentMorphemes } from "./content-morphemes.ts";
+import { formValueTokens, isFormBlock } from "./form-line.ts";
 import { trigrams } from "./heading-overlap.ts";
 import { findingAt, writtenHeadings } from "./markup-finding.ts";
 import type { Detector, Finding, LengthUnit, MarkupHeading, Paragraph, ProseDocument, Section } from "../plugin.ts";
@@ -38,6 +39,13 @@ const leadOf = (doc: ProseDocument): Lead | undefined => {
   const lead = title === undefined ? undefined : leadParagraphOf(doc, title);
   if (title === undefined || lead === undefined || title.headingTokens === undefined) return undefined;
   const leadTokens = lead.sentences.flatMap((sentence) => sentence.tokens ?? []);
+  // A form or a letter opens with fields or a letterhead, not a lead (Invoice number: INV-2026-0318). A line that only copies the title is still one.
+  const leadSource = doc.source.slice(lead.span.start, lead.span.end);
+  if (
+    isFormBlock(leadSource, lead.span.start, leadTokens) &&
+    newContentMorphemes(title.headingTokens, formValueTokens(leadSource, lead.span.start, leadTokens)) > 0
+  )
+    return undefined;
   const leadText = lead.sentences.map((sentence) => sentence.text).join(" ");
   return { title, lead, fresh: newContentMorphemes(title.headingTokens, leadTokens), echo: echoPercent(title.heading, leadText) };
 };

package/src/detectors/due-date.ts

@@ -1,13 +1,15 @@
 // due-before-issue: the reading half. The issue-date and due-date words come from the language's lexicons
 // (issue-date-label, due-date-label, deadline-passed-word), and so do the words of minutes (minutes-title-word, meeting-date-label,
 // action-section-heading, earlier-section-word, action-due-label, item-done-word) and the other pairs of dates that must come in
-// order (dated-pair-label, date-now-word, and dated-span-label for the words whose line states a period, read up to its end;
-// a table whose header names both columns of a pair, from dated-pair-label and the header-only dated-column-label);
+// order (dated-pair-label, date-now-word, and dated-span-label for the words whose line states a period, read up to its end,
+// or from its start in the group a dated-span-label entry names;
+// a table whose header names both columns of a pair, from dated-pair-label and the header-only dated-column-label;
+// a signature line giving a pair's later date, from the role words of dated-signer-label);
 // the dates are the structure tree's, and the lines are read with code masked.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { actionDueBeforeMeeting, type ActionWords } from "../structure/action-due.ts";
 import { columnDatesOutOfOrder } from "../structure/column-date-order.ts";
-import { pairedDatesOutOfOrder, type OrderDate } from "../structure/labelled-date-order.ts";
+import { pairedDatesOutOfOrder, type OrderDate, type PairedIssue } from "../structure/labelled-date-order.ts";
 import { dueBeforeIssue, type DueWords } from "../structure/due-date.ts";
 import { inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { proseAndTablesOf } from "../table-text.ts";
@@ -50,17 +52,25 @@ const findingOf = (doc: ProseDocument, issue: StructureIssue, variant?: string):
   ...(variant === undefined ? {} : { variant }),
 });
 
+const variantOf = (issue: PairedIssue): string => {
+  if (issue.fromStart === true) return "period-start";
+  return issue.period ? "period" : "order";
+};
+
 export const dueDate: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const text = proseAndTablesOf(doc);
   const dates = treeDates(doc.structure);
   const pairs = doc.lexicons["dated-pair-label"] ?? [];
-  const spans = periodWordsOf(doc, patternsOf(doc, "dated-span-label"));
+  const spanEntries = doc.lexicons["dated-span-label"] ?? [];
+  const spans = { ...periodWordsOf(doc, [...new Set(spanEntries.map((entry) => entry.pattern))]), entries: spanEntries };
   return [
     ...dueBeforeIssue(text, dates, wordsOf(doc)).map((issue) => findingOf(doc, issue)),
-    ...pairedDatesOutOfOrder(text, dates, pairs, orderAsidesOf(doc), MAX_RECORD_LINE_GAP, spans).map((issue) =>
-      findingOf(doc, issue, issue.period ? "period" : "order"),
-    ),
+    ...pairedDatesOutOfOrder(text, dates, pairs, orderAsidesOf(doc), MAX_RECORD_LINE_GAP, {
+      spans,
+      whole: doc.source,
+      signers: doc.lexicons["dated-signer-label"] ?? [],
+    }).map((issue) => findingOf(doc, issue, variantOf(issue))),
     ...columnDatesOutOfOrder(text, dates, [...pairs, ...(doc.lexicons["dated-column-label"] ?? [])], orderAsidesOf(doc)).map((issue) =>
       findingOf(doc, issue, "order"),
     ),