chaffjs 0.33.0 → 0.35.0

package/src/commands/grade.ts

@@ -1,10 +1,11 @@
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { packageFor } from "../adapter-load.ts";
 import type { Config } from "../config/load.ts";
 import { readDocumentFile } from "../files.ts";
 import { GENRES } from "../genre.ts";
 import { gradeItem, type GradeSetup } from "../grade/grade-item.ts";
+import { expectProblems } from "../grade/expect-read.ts";
 import { DEFAULT_VARIANT_FIELD, ITEM_FIELDS, parseItems, type GradeItem, type VariantField } from "../grade/item.ts";
 import { renderMarkdown } from "../grade/render-markdown.ts";
 import { renderVariants, renderVariantsCompact } from "../grade/render-variants.ts";
@@ -14,6 +15,8 @@ import { renderCompact, renderSummary } from "../grade/render.ts";
 import type { GradeResult } from "../grade/result.ts";
 import { gradeSetup } from "../grade/setup.ts";
 import { parseRubric, type Rubric } from "../grade/rubric.ts";
+import { parseRubricFile, type RubricFileProblem } from "../grade/rubric-file.ts";
+import { rubricRuleEntries, taskNamesOf, taskRuleIds } from "../grade/task-rubric.ts";
 import { rulesOf } from "../custom/load.ts";
 import { summaryOf } from "../grade/summary.ts";
 import { GRADE_TEXT, type GradeText } from "../grade/text.ts";
@@ -26,7 +29,7 @@ import { chooseBaseline } from "./grade-baseline.ts";
 /** Exit codes (spec §29.3). 2 keeps "the grader did not run" apart from "an output is bad" at a CI gate. */
 export const GRADE_EXIT = { passed: 0, failed: 1, unreadable: 2 } as const;
 
-const VALUED: ReadonlySet<string> = new Set(["--out", "--genre", "--baseline", "--format", "--variant-key"]);
+const VALUED: ReadonlySet<string> = new Set(["--out", "--genre", "--baseline", "--format", "--variant-key", "--rubric"]);
 
 const FORMATS = ["text", "json", "markdown"] as const;
 
@@ -56,11 +59,13 @@ export type GradeContext = {
   readonly ui: UiLanguage;
 };
 
-const readItems = async (path: string, variantField: VariantField, text: GradeText): Promise<readonly GradeItem[] | undefined> => {
+type ReadItems = { readonly items: readonly GradeItem[]; readonly lines: readonly number[] };
+
+const readItems = async (path: string, variantField: VariantField, tasks: readonly string[], text: GradeText): Promise<ReadItems | undefined> => {
   try {
-    const vocabulary = { isLanguage: (language: string) => packageFor(language) !== undefined, genres: GENRES };
+    const vocabulary = { isLanguage: (language: string) => packageFor(language) !== undefined, genres: GENRES, tasks };
     const parsed = parseItems(await readDocumentFile(path), vocabulary, variantField);
-    if ("items" in parsed) return parsed.items;
+    if ("items" in parsed) return parsed;
     parsed.problems.forEach((problem) => console.error(`${path}: ${text.problem(problem)}`));
   } catch (error) {
     console.error(text.unreadable(path, error instanceof Error ? error.message : String(error)));
@@ -68,39 +73,75 @@ const readItems = async (path: string, variantField: VariantField, text: GradeTe
   return undefined;
 };
 
-/** The `grade:` rubric, or undefined after saying what is wrong with it. `rubric: undefined` is a run with no rubric. */
-const readRubric = (config: Config, text: GradeText): { readonly rubric: Rubric | undefined } | undefined => {
+/** The rubric a run grades by, and the --rubric file it came from when it came from one. */
+type RubricRead = { readonly rubric: Rubric | undefined; readonly file?: { readonly path: string; readonly digest: string } | undefined };
+
+/** chaff.yaml's `grade:` rubric, or undefined after saying what is wrong with it. `rubric: undefined` is a run with no rubric. */
+const readConfigRubric = (config: Config, text: GradeText): RubricRead | undefined => {
   const parsed = parseRubric(config.grade);
   if ("rubric" in parsed) return parsed;
   parsed.problems.forEach((problem) => console.error(`chaff: ${text.rubricProblem(problem)}`));
   return undefined;
 };
 
-/** A rule id under grade.rules that chaff does not know. Said once here; each result also lists it as not run. */
-const warnUnknownRules = (rubric: Rubric | undefined, config: Config, text: GradeText): void => {
+const fileProblemText = (path: string, problem: RubricFileProblem, text: GradeText): string => {
+  if (problem.kind === "format") return text.rubricFormat(path);
+  if (problem.kind === "syntax") return text.rubricSyntax(path, problem.why);
+  return text.rubricProblem(problem.problem, path);
+};
+
+/** A --rubric file's rubric, which replaces chaff.yaml's `grade:`, or undefined after saying why it cannot be read. */
+const readRubricFile = (path: string, text: GradeText): RubricRead | undefined => {
+  try {
+    const parsed = parseRubricFile(path, readFileSync(path, "utf8"));
+    if ("rubric" in parsed) return { rubric: parsed.rubric, file: { path, digest: parsed.digest } };
+    parsed.problems.forEach((problem) => console.error(fileProblemText(path, problem, text)));
+  } catch (error) {
+    console.error(text.unreadable(path, error instanceof Error ? error.message : String(error)));
+  }
+  return undefined;
+};
+
+const readRubric = (rubricPath: string | undefined, config: Config, text: GradeText): RubricRead | undefined =>
+  rubricPath === undefined ? readConfigRubric(config, text) : readRubricFile(rubricPath, text);
+
+/** A rule id under the rubric's rules that chaff does not know. Said once here; each result also lists it as not run. */
+const warnUnknownRules = (rubric: RubricRead, config: Config, text: GradeText): void => {
   const known = new Set(rulesOf(config.language ?? "en", config).map((rule) => rule.id));
-  Object.keys(rubric?.rules ?? {})
-    .filter((id) => !known.has(id))
-    .forEach((id) => console.error(`chaff: grade.rules.${id}: ${text.unknownRule}`));
+  const where = rubric.file === undefined ? "chaff: grade." : `${rubric.file.path}: `;
+  rubricRuleEntries(rubric.rubric)
+    .filter((entry) => !known.has(entry.id))
+    .forEach((entry) => console.error(`${where}${entry.path}.${entry.id}: ${text.unknownRule}`));
 };
 
 const setupFor = async (
   items: readonly GradeItem[],
-  rubric: Rubric | undefined,
+  rubric: RubricRead,
   argv: readonly string[],
   context: GradeContext,
   text: GradeText,
 ): Promise<GradeSetup | undefined> => {
   const languages = items.flatMap((item) => (item.language === undefined ? [] : [item.language]));
-  const run = { experimental: context.config.experimental || argv.includes("--experimental"), genre: context.flag(argv, "--genre") };
+  const run = {
+    experimental: context.config.experimental || argv.includes("--experimental"),
+    genre: context.flag(argv, "--genre"),
+    rubricFile: rubric.file?.digest,
+  };
   try {
-    return await gradeSetup(context.config, run, languages, rubric);
+    return await gradeSetup(context.config, run, languages, rubric.rubric);
   } catch (error) {
     console.error(text.cannotLoad(error instanceof Error ? error.message : String(error)));
     return undefined;
   }
 };
 
+/** Whether every expect entry is one fact; else says which are not, on their lines, before anything is graded. */
+const expectReadable = async (path: string, read: ReadItems, setup: GradeSetup, text: GradeText): Promise<boolean> => {
+  const problems = (await Promise.all(read.items.map((item, index) => expectProblems(item, read.lines[index] ?? 0, setup)))).flat();
+  problems.forEach((problem) => console.error(`${path}: ${text.problem(problem)}`));
+  return problems.length === 0;
+};
+
 /** One output after another, in the file's order: the results file lines up with the input. */
 const gradeInOrder = (items: readonly GradeItem[], setup: GradeSetup): Promise<GradeResult[]> =>
   items.reduce<Promise<GradeResult[]>>(async (previous, item) => [...(await previous), await gradeItem(item, setup)], Promise.resolve([]));
@@ -144,14 +185,24 @@ const printSummary = (path: string, results: readonly GradeResult[], compared: C
   } else printText(path, results, variants, compared, printing);
 };
 
-type RunOptions = { readonly path: string; readonly format: Format; readonly variantField: VariantField };
+type RunOptions = { readonly path: string; readonly format: Format; readonly variantField: VariantField; readonly rubric: string | undefined };
+
+/** --rubric's file: undefined when not given, null when given without one (a usage error, not a quiet fall back to chaff.yaml). */
+const rubricPathOf = (argv: readonly string[], context: GradeContext): string | undefined | null => {
+  if (!argv.includes("--rubric")) return undefined;
+  const path = context.flag(argv, "--rubric");
+  return path === undefined || path === "" || path.startsWith("--") ? null : path;
+};
 
 /** The file to grade and how to read and print it, or undefined after printing the usage. */
 const runOptionsOf = (argv: readonly string[], context: GradeContext): RunOptions | undefined => {
   const [path, ...extra] = gradeTargets(argv);
   const format = formatOf(argv, context);
   const variantField = variantFieldOf(argv, context);
-  if (path !== undefined && extra.length === 0 && format !== undefined && variantField !== undefined) return { path, format, variantField };
+  const rubric = rubricPathOf(argv, context);
+  if (path !== undefined && extra.length === 0 && format !== undefined && variantField !== undefined && rubric !== null) {
+    return { path, format, variantField, rubric };
+  }
   console.error(GRADE_TEXT[context.ui].usage);
   return undefined;
 };
@@ -171,16 +222,17 @@ export const runGrade = async (argv: readonly string[], context: GradeContext):
   const options = runOptionsOf(argv, context);
   if (options === undefined) return GRADE_EXIT.unreadable;
   const { path } = options;
-  const rubric = readRubric(context.config, host);
-  const items = rubric === undefined ? undefined : await readItems(path, options.variantField, host);
-  const setup = items === undefined || rubric === undefined ? undefined : await setupFor(items, rubric.rubric, argv, context, host);
-  if (setup === undefined || items === undefined) return GRADE_EXIT.unreadable;
+  const rubric = readRubric(options.rubric, context.config, host);
+  const read = rubric === undefined ? undefined : await readItems(path, options.variantField, taskNamesOf(rubric.rubric), host);
+  const setup = read === undefined || rubric === undefined ? undefined : await setupFor(read.items, rubric, argv, context, host);
+  if (setup === undefined || read === undefined || rubric === undefined || !(await expectReadable(path, read, setup, host))) return GRADE_EXIT.unreadable;
+  const { items } = read;
   const baseline = await chooseBaseline(context.flag(argv, "--baseline"), setup.stamp, argv.includes("--allow-stamp-mismatch"), context.ui);
   if (baseline.kind === "stop") return GRADE_EXIT.unreadable;
-  warnUnknownRules(setup.rubric, context.config, host);
+  warnUnknownRules(rubric, context.config, host);
   const results = await gradeInOrder(items, setup);
   writeResults(context.flag(argv, "--out"), results, host);
-  const rubricRules = new Set(Object.keys(setup.rubric?.rules ?? {}));
+  const rubricRules = (result: GradeResult): ReadonlySet<string> => taskRuleIds(setup.rubric, result.task);
   const compared = baseline.kind === "compare" ? { path: baseline.path, comparison: compareRuns(baseline.before, results, rubricRules) } : undefined;
   const ui = sharedLanguage(
     results.map((result) => result.language),

package/src/company-kana-spelling.ts

@@ -42,7 +42,26 @@ export const kanjiReadingOf = (
 const baseStartOf = (mention: CompanyMention): number =>
   mention.position === "after" ? mention.offset : mention.offset + mention.surface.length - mention.base.length;
 
-/** 会社の名前の、漢字一字をその読みのひらがなかカタカナで書いた形（みどりの生命保険株式会社、みどりノ生命保険株式会社）。 */
+/** 濁る頭の音（カ行、サ行、タ行、ハ行）。 */
+const VOICEABLE = /^[カキクケコサシスセソタチツテトハヒフヘホ]/u;
+const VOICED_MARK = "゙";
+
+/** 名前の中ほどの字の読みは、頭の音を濁らせて書くことがある（こむぎ畑 ハタケ を こむぎばたけ）。頭の音が濁らない読みには無い。 */
+export const voicedReadingOf = (reading: string): string | undefined => {
+  const first = VOICEABLE.exec(reading)?.[0];
+  return first === undefined ? undefined : `${(first + VOICED_MARK).normalize("NFC")}${reading.slice(first.length)}`;
+};
+
+/** 名前の字の読みの、かなの書き方。名前の頭でない字は、頭の音を濁らせた読みも。 */
+const readingsAt = (reading: string, inside: boolean): string[] => {
+  const voiced = inside ? voicedReadingOf(reading) : undefined;
+  return voiced === undefined ? [reading] : [reading, voiced];
+};
+
+/**
+ * 会社の名前の、漢字一字をその読みのひらがなかカタカナで書いた形（みどりの生命保険株式会社、みどりノ生命保険株式会社）。
+ * 名前の頭でない字は、頭の音を濁らせた読みでも（こむぎばたけベーカリー）。
+ */
 export const kanaSpellingsOf = (mention: CompanyMention, words: readonly ReadWord[]): string[] => {
   const baseStart = baseStartOf(mention);
   const baseEnd = baseStart + mention.base.length;
@@ -53,7 +72,8 @@ export const kanaSpellingsOf = (mention: CompanyMention, words: readonly ReadWor
       if (read === undefined) return [];
       const at = word.start - mention.offset + read.index;
       const [before, after] = [mention.surface.slice(0, at), mention.surface.slice(at + read.kanji.length)];
-      return [toHiragana(read.reading), read.reading].map((kana) => `${before}${kana}${after}`);
+      const inside = word.start + read.index > baseStart;
+      return readingsAt(read.reading, inside).flatMap((reading) => [toHiragana(reading), reading].map((kana) => `${before}${kana}${after}`));
     });
 };
 

package/src/company-name-ending.ts

@@ -0,0 +1,50 @@
+// 会社の名前の一語の終わりだけの違い。長い語の終わりの二字まで（Brightmoor と Brightmore、Lumenvale と Lumenvail）と、最後の語の
+// 単数と複数（Water Utility と Water Utilities）。名前のほかの語は同じもの。
+
+const LATIN_WORD = /^[a-z]+$/u;
+
+/** 終わりの二字の違いを見る語の長さ。短い語（Alpha と Alpine）は別の名前のことが多い。 */
+const MIN_ENDING_WORD_LENGTH = 8;
+/** 頭からそろった字の後ろに残る字の数。 */
+const MAX_ENDING_LENGTH = 2;
+
+const wordsOf = (base: string): string[] =>
+  base
+    .toLowerCase()
+    .split(/\s+/u)
+    .filter((word) => word !== "");
+
+/** 二つの名前の語の数が同じで、違うのが一語だけなら、その語の組と位置。 */
+const differingWord = (left: string, right: string): { readonly pair: readonly [string, string]; readonly last: boolean } | undefined => {
+  const [leftWords, rightWords] = [wordsOf(left), wordsOf(right)];
+  const differing = leftWords.flatMap((word, index) => (word === rightWords[index] ? [] : [index]));
+  const [at] = differing;
+  const [leftWord, rightWord] = [leftWords[at ?? -1], rightWords[at ?? -1]];
+  if (leftWords.length !== rightWords.length || differing.length !== 1 || leftWord === undefined || rightWord === undefined) return undefined;
+  return { pair: [leftWord, rightWord], last: at === leftWords.length - 1 };
+};
+
+const sharedPrefix = (left: string, right: string): number => {
+  const differ = [...left].findIndex((char, index) => char !== right.charAt(index));
+  return differ < 0 ? left.length : differ;
+};
+
+/** 八字以上の英字の語の、頭がそろい、終わりの二字までだけが違うか（moor と more）。 */
+export const isEndingApart = (left: string, right: string): boolean => {
+  if (left === right || !LATIN_WORD.test(left) || !LATIN_WORD.test(right) || Math.min(left.length, right.length) < MIN_ENDING_WORD_LENGTH) return false;
+  const prefix = sharedPrefix(left, right);
+  return left.length - prefix <= MAX_ENDING_LENGTH && right.length - prefix <= MAX_ENDING_LENGTH;
+};
+
+/** 片方が他方の複数の形か（Tool と Tools、Box と Boxes、Utility と Utilities）。 */
+export const isPluralOf = (singular: string, plural: string): boolean =>
+  LATIN_WORD.test(singular) &&
+  (plural === `${singular}s` || plural === `${singular}es` || (singular.endsWith("y") && plural === `${singular.slice(0, -1)}ies`));
+
+/** 二つの会社の名前の部分が、一語の終わりだけ違うか。長い語の終わりの二字までか、最後の語の単数と複数。 */
+export const isNameEndingSlip = (left: string, right: string): boolean => {
+  const differing = differingWord(left, right);
+  if (differing === undefined) return false;
+  const [leftWord, rightWord] = differing.pair;
+  return isEndingApart(leftWord, rightWord) || (differing.last && (isPluralOf(leftWord, rightWord) || isPluralOf(rightWord, leftWord)));
+};

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,20 +346,46 @@ 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;
 };
 
-/** 同じ会社の、少ないほうの書き方。同じ会社と言える相手のうち一番多いものと比べる。書き方ごとに最初の現れを一つ。 */
+/** 会社のグループと見る、同じ名前の部分に付く形の組の数。 */
+const MIN_GROUP_FORMS = 3;
+
+/**
+ * 三つ以上の形の組で書いた名前の部分（GitLab Inc、GitLab Ltd、GitLab GmbH）。国ごとの会社を並べたグループで、形の違いは別の会社を
+ * 言い分けている。比べる形（nameKey）で。
+ */
+export const companyGroupBases = (mentions: readonly CompanyMention[]): Set<string> => {
+  const forms = new Map<string, Set<string>>();
+  mentions.forEach((mention) => {
+    const base = nameKey(mention.base);
+    forms.set(base, (forms.get(base) ?? new Set()).add(mention.form));
+  });
+  return new Set([...forms].flatMap(([base, groups]) => (groups.size >= MIN_GROUP_FORMS ? [base] : [])));
+};
+
+/** 同じ会社の、少ないほうの書き方。同じ会社と言える相手のうち一番多いものと比べる。会社のグループの形の違いは比べない。書き方ごとに最初の現れを一つ。 */
 export const companyVariants = (mentions: readonly CompanyMention[]): CompanyVariant[] => {
   const tallies = talliesOf(mentions);
+  const groups = companyGroupBases(mentions);
+  const relationOf = (tally: Tally, other: Tally): CompanyRelation | undefined => {
+    const relation = relationBetween(tally, other);
+    return relation === "form" && groups.has(nameKey(tally.first.base)) ? undefined : relation;
+  };
   return tallies.flatMap((tally) => {
-    const [usual] = tallies.filter((other) => other === tally || relationBetween(tally, other) !== undefined).toSorted(byUsage);
-    const kind = usual === undefined || usual === tally ? undefined : relationBetween(tally, usual);
+    const [usual] = tallies.filter((other) => other === tally || relationOf(tally, other) !== undefined).toSorted(byUsage);
+    const kind = usual === undefined || usual === tally ? undefined : relationOf(tally, usual);
     return usual === undefined || kind === undefined ? [] : [{ mention: tally.first, usual: usual.first.surface, kind }];
   });
 };

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/acronym-context.ts

@@ -1,14 +1,15 @@
-import { escapeRegExp } from "../orthography.ts";
 import { ROMAN_NUMERAL, romanRangeOf } from "./roman-numeral.ts";
 import { citationKeySpans } from "./citation-key.ts";
 import { dottedNameSpans } from "./dotted-name.ts";
 import { letterJoinedNameSpans } from "./letter-joined-name.ts";
 import { loneNumeralSpans, nameNumeralSpans } from "./name-numeral.ts";
 import { placeholderSpans } from "./placeholder.ts";
+import { numeralWordSpans } from "./numeral-word.ts";
 import { seriesLabelSpans } from "./series-label.ts";
+import { oneOf } from "./acronym-name.ts";
 
 /**
- * 大文字の語が略語ではなく、決まった書き方の一部として読める所（3:30 PM、1pm ET、USD 1,000、Kansas City, MO 64108）。
+ * 大文字の語が略語ではなく、決まった書き方の一部として読める所（3:30 PM、1pm ET、USD 1,000、Kansas City, MO 64108、Fort Lauderdale FL 33304）。
  * どれも閉じた集合で、しかも隣の数字（州は地名でもよい）があるときだけ認める。PM（project manager）、CT、CA（certificate authority）は
  * その隣でなければ略語のまま数える。語は言語パッケージの語彙表から読み、書き方の組み立てだけをここに置く。
  */
@@ -34,9 +35,6 @@ export type NotationWords = {
   readonly dateTimeUnits: readonly string[];
 };
 
-// 空の語彙表は「その書き方が無い」。空の選択肢 (?:) は至る所で空文字に当たるので、何にも当たらない形にする。
-const oneOf = (words: readonly string[]): string => (words.length === 0 ? "(?!)" : `(?:${words.map(escapeRegExp).join("|")})`);
-
 const MINUTES = String.raw`:[0-5]\d`;
 const CLOCK_12 = String.raw`(?<![\d:.])(?:1[0-2]|0?[1-9])(?:${MINUTES})?`;
 const CLOCK_24 = String.raw`(?<![\d:.])(?:[01]?\d|2[0-3])${MINUTES}`;
@@ -88,7 +86,7 @@ const patternsOf = (words: NotationWords): readonly RegExp[] => [
   new RegExp(String.raw`(?:${CLOCK_24}|${CLOCK_12}\s*${ANY_MERIDIEM})\s*${oneOf(words.timeZones)}`, "gu"),
   new RegExp(String.raw`${oneOf(words.currencies)}\s*[$€£¥]?${AMOUNT}`, "gu"),
   new RegExp(String.raw`(?<![\w.,])${AMOUNT}\s*${oneOf(words.currencies)}`, "gu"),
-  new RegExp(String.raw`,\s+${oneOf(words.usStates)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
+  new RegExp(String.raw`(?:,\s+|(?<=(?<!\p{L})\p{Lu}\p{Ll}+)\s+)${oneOf(words.usStates)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
   placeAndState(oneOf(words.usStates)),
   new RegExp(oneOf(words.emphasis), "gu"),
   ...numberedPatterns(words),
@@ -113,5 +111,6 @@ export const notAcronymSpansOf = (words: NotationWords): NotAcronymSpans => {
     ...loneNumeralSpans(text),
     ...seriesLabelSpans(text),
     ...placeholderSpans(text, words.dateTimeUnits),
+    ...numeralWordSpans(text),
   ];
 };