chaffjs 0.34.0 → 0.36.0

package/rules/use-before-definition.yaml

@@ -50,8 +50,8 @@ example:
       This agreement is between Harbour Ltd (the "Seller") and Hill Ltd (the "Buyer"). The Seller ships within five days.
 
 not_flagged:
-  ja: 定義の条（「X」とは…をいう）で定義した語は、前で使っても言いません。定義の条は文書の頭にも終わりにも置く書き方があるためです。規約やポリシーの丁寧な形（以下「X」といいます）も、法令の形と同じに読みます。見出しの行（章・節の行、条の前の「（買主の義務）」のような見出し）の語と、漢字で終わる語にさらに漢字が続く長い語（「監査委員会」の「監査委員」）と、定義の括弧の前の長い名前をそのまま書いた所（「…作成の手引き（以下「手引き」という。）」より前の「…作成の手引き」）は、使った所に数えません。最初の一か所だけを指します。別の語を定義する括弧の前の名前の中（This Services Agreement (this "Agreement") の Services、本サービス利用契約（以下「本契約」という。）の本サービス）も、使った所に数えません。
-  en: Terms defined in a definitions clause ("X" means ...) are not checked, since a definitions clause may come first or last. A heading line (a chapter or section line, or the caption above an article) does not count as a use, nor does a longer word that runs on in kanji past a term ending in kanji, nor an earlier copy of the long name written just before the definition's bracket. The polite Japanese form (以下「X」といいます) is read like the statute form. Only the first early use is pointed at. A word inside the name written right before another term's defining bracket (Services in This Services Agreement (this "Agreement")) is not a use either.
+  ja: 定義の条（「X」とは…をいう）で定義した語は、前で使っても言いません。定義の条は文書の頭にも終わりにも置く書き方があるためです。規約やポリシーの丁寧な形（以下「X」といいます）も、法令の形と同じに読みます。見出しの行（章・節の行、条の前の「（買主の義務）」のような見出し）の語と、漢字で終わる語にさらに漢字が続く長い語（「監査委員会」の「監査委員」）と、定義の括弧の前の長い名前をそのまま書いた所（「…作成の手引き（以下「手引き」という。）」より前の「…作成の手引き」）は、使った所に数えません。最初の一か所だけを指します。別の語を定義する括弧の前の名前の中（This Services Agreement (this "Agreement") の Services、本サービス利用契約（以下「本契約」という。）の本サービス）も、使った所に数えません。目次・索引の行（目次の見出しの下の項目、一行に詰めた目次、定義した語と条の番地の一覧）と、条の番号の後ろの題（Section 1.1 Closing.）と、語を含むもっと長い名前（定義の括弧の前の名前を前で写した株式会社みなと、もっと長い定義した語、Navistar Financial Corporation）も数えません。文書自身の名前と定義した語に同じ頭を付けた所（この就業規則（以下「規則」）より前の「この規則」）と、すぐ後ろの括弧に定義の長い名前を書き添えた所は、読み手に分かるので言いません。
+  en: Terms defined in a definitions clause ("X" means ...) are not checked, since a definitions clause may come first or last. A heading line (a chapter or section line, or the caption above an article) does not count as a use, nor does a longer word that runs on in kanji past a term ending in kanji, nor an earlier copy of the long name written just before the definition's bracket. The polite Japanese form (以下「X」といいます) is read like the statute form. Only the first early use is pointed at. A word inside the name written right before another term's defining bracket (Services in This Services Agreement (this "Agreement")) is not a use either. Nor are contents and index lines (the items under a contents heading, a table of contents or a list of defined terms and section numbers packed on one line), a caption after a section number (Section 1.1 Closing.), or a longer name that holds the term, such as an earlier copy of the name before the bracket (Board of Directors before our Board of Directors ("Board")), a longer defined term, a capitalised name ending in it (Navistar Financial Corporation). The document naming itself (this Agreement before (this "Agreement")) and a use followed by the long name in brackets are clear to the reader and not pointed at.
 rewrite:
   depth: structure
   ja:

package/rules/vague-word-density.yaml

@@ -53,8 +53,8 @@ example:
       Report an incident within 30 minutes and notify the affected teams. Record it in the incident log and fix the cause by the next working day.
 
 not_flagged:
-  ja: 文書の長さに対して少ないものは指しません。短すぎる文書も測りません。要求の文の中の「可能な限り」「必要に応じて」は、要求の書き方として requirement-smell も見ます。
-  en: A few vague words for the document's length are not reported, and very short documents are not measured. Inside a requirement, requirement-smell also reads "where possible" and "as needed".
+  ja: 文書の長さに対して少ないものは指しません。短すぎる文書も測りません。指すのは語のある文ごとに一度で、長い言い方の中の語（in a timely manner の timely）は一つと数えます。英語の法務の文書では、法律や慣行が意味を決めている言い方（reasonable、best efforts、from time to time）の中の語は数えません。要求の文の中の「可能な限り」「必要に応じて」は、要求の書き方として requirement-smell も見ます。すぐ後ろの括弧で中身を書いた語（一定の事項（請求書に書く事項））も数えません。括弧が名前を付けるだけ（以下「本措置」という。）なら数えます。
+  en: 'A few vague words for the document''s length are not reported, and very short documents are not measured. Each sentence is reported once, and a word inside a longer phrase ("timely" in "in a timely manner") counts once. In legal documents, a word inside a term that law and practice define ("reasonable", "best efforts", "from time to time") is not counted. Inside a requirement, requirement-smell also reads "where possible" and "as needed". A word that the bracket right after it pins down ("a reasonable fee (USD 50)") is not counted either; a bracket that only names it ("(hereinafter the ""Fee"")") pins nothing down.'
 level_meaning:
   ja: 1000 字あたりあいまいな語 {limit} 個まで
   en: up to {limit} vague words per 1000 words

package/skills/chaff/SKILL.md

@@ -31,7 +31,9 @@ read. A contract checked as a blog post gets wrong findings, so choose the genre
    guessed or default genre shows no guide, and `--no-guide` leaves it out.
 
 A rule the genre turns off is listed under "did not run" with the genre as the reason. That is the preset's
-choice, not a gap; turn it back on (`rules:` in `chaff.yaml`) only when the person asks.
+choice, not a gap; turn it back on (`rules:` in `chaff.yaml`) only when the person asks. Some of these are off
+because chaff measured them to be mostly wrong for that kind of document on real, judged documents
+([isamu/chaff-corpus](https://github.com/isamu/chaff-corpus)); turning one back on brings those false findings back.
 
 ## Run it
 
@@ -75,6 +77,10 @@ calls nothing. Ask the person before a real run; the passages leave the machine.
 `npx chaffjs explain <rule-id>` shows why a rule exists, its levels and the current one. Read it before
 relaxing a rule.
 
+When a finding is wrong for a reason that is not about this team (chaff misread the text), tell the person and offer
+`npx chaffjs feedback <file> --rule <rule-id> --line <n>`: it drafts a report and sends nothing. A document the
+person may share can go to isamu/chaff-corpus, where wrong findings become test cases and rule fixes.
+
 ## When numbers or dates disagree
 
 The group "Facts that disagree" in `npx chaffjs rules` checks what a sum or a calendar can settle. Among them:

package/src/announced-count.ts

@@ -20,6 +20,8 @@ export type CountWords = {
   readonly hedgesBefore: readonly string[];
   /** 数か数える語のすぐ後ろにあると予告でなくなる語（以上、目、or more）。 */
   readonly hedgesAfter: readonly string[];
+  /** 数と合わせて、その一行だけで下の並びの数を言う見出しの語（3行要約、three-line summary）。 */
+  readonly titles: readonly string[];
 };
 
 export type CountMismatch = { readonly offset: number; readonly phrase: string; readonly announced: number; readonly listed: number };
@@ -101,7 +103,17 @@ const numberPattern = (words: CountWords): RegExp => {
   return new RegExp(latin.length === 0 ? digits : `${digits}|(?<![A-Za-z])(?:${alternation(latin)})(?![A-Za-z])`, "iu");
 };
 
-type Patterns = { readonly phrase: RegExp; readonly number: RegExp };
+/**
+ * 予告の塊が一行で、数と見出しの語だけ（3行要約、**Three-line summary:**）。前後でそろった強調の印と終わりのコロンは許す。
+ * 文の中の「3行要約を書いた」は予告でない。
+ */
+const titlePattern = (words: CountWords): RegExp | undefined => {
+  if (words.titles.length === 0) return undefined;
+  const numbers = words.numbers.length === 0 ? "\\p{Nd}+" : `\\p{Nd}+|${alternation(words.numbers)}`;
+  return new RegExp(`^([ \\t]*(\\*\\*|__|\\*|_)?)((${numbers})[ \\t]?(?:${alternation(words.titles)}))\\2[ \\t]*[:：]?[ \\t]*$`, "iu");
+};
+
+type Patterns = { readonly phrase: RegExp; readonly number: RegExp; readonly title: RegExp | undefined };
 
 /**
  * 数える語の無い数は、先を指す語のすぐ後ろでだけ（the following two:）。「under $75:」の金額を数に読まない。
@@ -181,20 +193,35 @@ const matchesList = (announced: number, source: string, list: BulletList): boole
 
 type Context = { readonly source: string; readonly words: CountWords; readonly patterns: Patterns; readonly neighbours: Neighbours };
 
+/** 予告の塊のどこに、何と書いて、いくつと言ったか。 */
+type Announcement = { readonly start: number; readonly phrase: string; readonly announced: number };
+
+/** 最後の一文の予告（以下の3点）か、塊が見出しの語句だけの予告（3行要約）。 */
+const announcementIn = (lead: string, words: CountWords, patterns: Patterns): Announcement | undefined => {
+  const sentenceStart = lastSentenceStart(lead);
+  const sentence = lead.slice(sentenceStart);
+  const phrase = announcedIn(sentence, words, patterns);
+  if (phrase !== undefined)
+    return { start: sentenceStart + phrase.start, phrase: sentence.slice(phrase.start, phrase.end).trim(), announced: phrase.announced };
+  const title = patterns.title?.exec(lead);
+  const written = title?.[3];
+  if (title === null || title === undefined || written === undefined) return undefined;
+  const announced = valueOf(title[4] ?? "", words.numbers);
+  return announced < 1 ? undefined : { start: (title[1] ?? "").length, phrase: written, announced };
+};
+
 const mismatchOf = ({ source, words, patterns, neighbours }: Context, list: BulletList): CountMismatch[] => {
   if (hasNeighbour(source, list.span, neighbours)) return [];
   const lead = leadBefore(source, list.span.start);
   if (lead === undefined) return [];
-  const sentenceStart = lastSentenceStart(lead.text);
-  const sentence = lead.text.slice(sentenceStart);
-  const phrase = announcedIn(sentence, words, patterns);
-  if (phrase === undefined || matchesList(phrase.announced, source, list)) return [];
-  const offset = lead.start + sentenceStart + phrase.start;
-  return [{ offset, phrase: sentence.slice(phrase.start, phrase.end).trim(), announced: phrase.announced, listed: list.items.length }];
+  const announcement = announcementIn(lead.text, words, patterns);
+  if (announcement === undefined || matchesList(announcement.announced, source, list)) return [];
+  return [{ offset: lead.start + announcement.start, phrase: announcement.phrase, announced: announcement.announced, listed: list.items.length }];
 };
 
 export const announcedCountMismatches = (source: string, lists: readonly BulletList[], words: CountWords): CountMismatch[] => {
   if (words.counters.length === 0) return [];
-  const context = { source, words, patterns: { phrase: phrasePattern(words), number: numberPattern(words) }, neighbours: neighboursOf(source, lists) };
+  const patterns = { phrase: phrasePattern(words), number: numberPattern(words), title: titlePattern(words) };
+  const context = { source, words, patterns, neighbours: neighboursOf(source, lists) };
   return lists.flatMap((list) => mismatchOf(context, list));
 };

package/src/capitals-passage.ts

@@ -0,0 +1,31 @@
+// A word set in capitals because the passage around it is (a disclaimer, a heading or a running header in capitals): eGAIN in
+// "eGAIN AND ITS SUPPLIERS MAKE NO WARRANTY" is the passage's capitals, not another spelling of eGain.
+
+/** Words read on each side of the span, in its sentence and on its line. */
+const NEIGHBOURS = 3;
+/** Words, the span's own included, that make a passage rather than one word in capitals. */
+const MIN_PASSAGE_WORDS = 3;
+/** How far to look on each side (UTF-16 units): three words, however long, fit. */
+const WINDOW = 200;
+const WORD = /\p{Script=Latin}[\p{Script=Latin}\p{N}'’]*/gu;
+const LOWER = /\p{Ll}/u;
+/** The end of a sentence or a line: the passage does not run across it ("7. Warranty. THE SYSTEMS ARE …"). */
+const STOP = /[.!?;:]\s|\n/gu;
+
+/** A word in capitals after its first letter (WARRANTY, eGAIN, eGAIN'S). */
+const isCapitalsWord = (word: string): boolean => !LOWER.test([...word].slice(1).join(""));
+
+/** The Latin words of two letters or more: a one-letter word (a, I) says nothing about the passage. */
+const wordsIn = (text: string): string[] => [...text.matchAll(WORD)].map((match) => match[0]).filter((word) => [...word].length >= 2);
+
+const afterLastStop = (text: string): string => text.slice(Math.max(0, ...[...text.matchAll(STOP)].map((match) => match.index + match[0].length)));
+
+const beforeFirstStop = (text: string): string => text.slice(0, [...text.matchAll(STOP)][0]?.index ?? text.length);
+
+/** Whether the words of text[start, end) and up to three words on each side of it, in its sentence, are all in capitals, three or more of them. */
+export const isInCapitalsPassage = (text: string, start: number, end: number): boolean => {
+  const before = wordsIn(afterLastStop(text.slice(Math.max(0, start - WINDOW), start))).slice(-NEIGHBOURS);
+  const after = wordsIn(beforeFirstStop(text.slice(end, end + WINDOW))).slice(0, NEIGHBOURS);
+  const words = [...before, ...wordsIn(text.slice(start, end)), ...after];
+  return words.length >= MIN_PASSAGE_WORDS && words.every(isCapitalsWord);
+};

package/src/chronology-rows.ts

@@ -0,0 +1,86 @@
+import { calendarUnitsOf, type CalendarUnits } from "./calendar-number.ts";
+import type { ProseDocument, Sentence } from "./plugin.ts";
+
+/**
+ * 年表の行（「1950年4月 設立」「2003年４月大阪証券取引所上場廃止。」）。日付で始まり、すぐに出来事を書く。
+ * 行は名詞で止め、文書の文体とも合わせないのが年表の書き方なので、本文の文として数えない。
+ *
+ * 日付で始まる文が 1 つだけなら本文（「2020年4月当社は…」）。続けて MIN_ROWS 以上並んだときだけ年表と読む。
+ * 行の注記（「当時主要製品は…」）が MAX_GAP 文まで挟まっても同じ年表の続きで、注記も年表の中身として数えない。
+ */
+const MIN_ROWS = 3;
+const MAX_GAP = 4;
+
+/** 日付のすぐ後ろにあれば、日付は文の一部で年表の見出しではない（2020年に、2020年4月、当社は）。 */
+const JOINS_DATE = /^[\p{Script=Hiragana}\p{P}\p{Sm}]/u;
+const DIGITS = /^[0-9０-９]+/u;
+const CALENDAR_YEAR_DIGITS = 4;
+
+type Part = { readonly digits: number; readonly rank: number; readonly end: number };
+
+/** 数（全角も）と、その後ろ（空白 1 つまで）の単位。単位が units.chained に無ければ undefined。 */
+const partAt = (text: string, at: number, units: CalendarUnits): Part | undefined => {
+  const digits = DIGITS.exec(text.slice(at))?.[0];
+  if (digits === undefined) return undefined;
+  const unitAt = text[at + digits.length] === " " ? at + digits.length + 1 : at + digits.length;
+  const rank = units.chained.findIndex((unit) => text.startsWith(unit, unitAt));
+  const unit = units.chained[rank];
+  if (unit === undefined) return undefined;
+  // 「2020年度」は年度という別の語で、年表の日付ではない。
+  if ([...units.year].some((word) => word.length > unit.length && text.startsWith(word, unitAt))) return undefined;
+  return { digits: digits.length, rank, end: unitAt + unit.length };
+};
+
+/** 前より小さい単位（年の後ろの月、月の後ろの日）が続く限り延ばした日付の終わり。 */
+const chainEnd = (text: string, last: Part, units: CalendarUnits): number => {
+  const next = partAt(text, last.end, units);
+  return next !== undefined && next.rank > last.rank ? chainEnd(text, next, units) : last.end;
+};
+
+/** 文の頭の見出しの札（「２【沿革】」）。本文に流し込んだ見出しの後ろから、最初の行が始まる。 */
+const LEADING_LABEL = /^\s*(?:[0-9０-９]+\s*)?【[^】\n]*】\s*/u;
+
+/** 文の頭（空白と見出しの札を除く）の、年から始まる日付（1950年4月、昭和56年11月1日）の終わり。年は 4 桁か元号付き。日付で始まらなければ undefined。 */
+const leadingDateEnd = (text: string, units: CalendarUnits): number | undefined => {
+  const lead = LEADING_LABEL.exec(text)?.[0].length ?? text.length - text.trimStart().length;
+  const era = units.era.find((name) => text.startsWith(name, lead));
+  const year = partAt(text, lead + (era?.length ?? 0), units);
+  if (year === undefined || year.rank !== 0 || (era === undefined && year.digits !== CALENDAR_YEAR_DIGITS)) return undefined;
+  return chainEnd(text, year, units);
+};
+
+/** 年から始まる日付で始まり、助詞も句読点も挟まずに出来事が続く文か。units は日付の単位（年月日の順）と元号。 */
+export const opensWithDateStamp = (text: string, units: CalendarUnits): boolean => {
+  const end = leadingDateEnd(text, units);
+  if (end === undefined) return false;
+  const rest = text.slice(end).trimStart();
+  return rest !== "" && !JOINS_DATE.test(rest);
+};
+
+/** heads[i] が日付で始まる文。年表と読む文の番号（MAX_GAP 文までの間を挟んで MIN_ROWS 以上続く行と、行の間の注記）。 */
+export const chronologyRowIndexes = (heads: readonly boolean[]): ReadonlySet<number> => {
+  const dated = heads.flatMap((head, index) => (head ? [index] : []));
+  const clusters = dated.reduce<number[][]>((acc, index) => {
+    const cluster = acc.at(-1);
+    const previous = cluster?.at(-1);
+    if (cluster !== undefined && previous !== undefined && index - previous - 1 <= MAX_GAP) cluster.push(index);
+    else acc.push([index]);
+    return acc;
+  }, []);
+  return new Set(
+    clusters
+      .filter((cluster) => cluster.length >= MIN_ROWS)
+      .flatMap((cluster) => Array.from({ length: (cluster.at(-1) ?? 0) - (cluster[0] ?? 0) + 1 }, (_, offset) => (cluster[0] ?? 0) + offset)),
+  );
+};
+
+/** 主題の「は」。年表の行は出来事だけを書き、主題を立てない。立てた文（2021年売上高は110億円です。）は日付で始まっても本文。 */
+const TOPIC = "は";
+const hasTopic = (sentence: Sentence): boolean => (sentence.tokens ?? []).some((token) => token.surface === TOPIC && token.pos === "ADP");
+
+/** 文書の中の、年表の行の文。 */
+export const chronologyRows = (doc: ProseDocument): ReadonlySet<Sentence> => {
+  const units = calendarUnitsOf(doc);
+  const rows = chronologyRowIndexes(doc.sentences.map((sentence) => opensWithDateStamp(sentence.text, units) && !hasTopic(sentence)));
+  return new Set(doc.sentences.filter((_, index) => rows.has(index)));
+};

package/src/coined-hyphen-name.ts

@@ -0,0 +1,27 @@
+// A name coined from pieces joined by hyphens (Medi-Cal, the name of a programme): the pieces after the first are capitalised
+// and one of them is not a word. Closed up, its letters spell an ordinary word (medical), which is another word and not another
+// spelling of the name.
+
+const CAPITALISED = /^\p{Lu}\p{Ll}+$/u;
+
+/** Whether a hyphenated word is a coined name. isWord says whether a lower-case word is in the language's dictionary. */
+export const isCoinedName = (word: string, isWord: (word: string) => boolean): boolean => {
+  const later = word.split("-").slice(1);
+  return later.length > 0 && later.every((part) => CAPITALISED.test(part)) && later.some((part) => !isWord(part.toLowerCase()));
+};
+
+const UPPER = /\p{Lu}/u;
+
+/**
+ * The words without the coined names whose key the document otherwise writes only in small letters (Medi-Cal beside medical).
+ * Beside a spelling with capitals of its own (Wi-Fi beside WiFi) the coined name is still a spelling of that name. spelling is the
+ * word with the first letter of each part in small letters.
+ */
+export const withoutCoinedNames = <Word extends { readonly key: string; readonly spelling: string; readonly shown?: string }>(
+  words: readonly Word[],
+  isWord: (word: string) => boolean,
+): Word[] => {
+  const isCoined = (word: Word): boolean => isCoinedName(word.shown ?? word.spelling, isWord);
+  const capitalKeys = new Set(words.filter((word) => !isCoined(word) && UPPER.test(word.spelling)).map((word) => word.key));
+  return words.filter((word) => !isCoined(word) || capitalKeys.has(word.key));
+};

package/src/company-name-run.ts

@@ -0,0 +1,37 @@
+import { escapeRegExp } from "./orthography.ts";
+import type { Span } from "./plugin.ts";
+
+/** 会社の名前に使う字（漢字・片仮名・英数字）の続き。かなや句読点で名前は切れる。 */
+const NAME_RUN = /[\p{Script=Han}ァ-ヺーA-Za-zＡ-Ｚａ-ｚ0-9０-９&＆・]+/gu;
+
+/** 漢字か片仮名を含む形（株式会社、㈱、(株)）。英字だけの形は日本語の名前の目印にならない。 */
+const NOT_LATIN = /[^\p{Script=Latin}\p{P}\s]/u;
+
+const formPattern = (forms: readonly string[]): RegExp =>
+  new RegExp(
+    [...forms]
+      .sort((a, b) => b.length - a.length)
+      .map(escapeRegExp)
+      .join("|"),
+    "gu",
+  );
+
+/** at を含むか、at で接する名前の字の続き。 */
+const runAround = (runs: readonly Span[], at: number): Span | undefined => runs.find((run) => run.start <= at && at <= run.end);
+
+/**
+ * text の中の、日本の会社の形（語彙表 company-form）とその隣の名前の範囲（関東珪曹硝子㈱、株式会社ADEKA）。
+ * 名前は書き手が選べない字で書かれるので、表記のゆれを数える語に入れない。形の前は名前の字が続くかぎり、形の後ろも同じ。
+ * 名前の字の続きを一度だけ求め、形の両端をそれに合わせて伸ばす。
+ */
+export const japaneseCompanyNameSpans = (text: string, forms: readonly string[]): Span[] => {
+  const japanese = forms.filter((form) => NOT_LATIN.test(form));
+  if (japanese.length === 0) return [];
+  const found = [...text.matchAll(formPattern(japanese))];
+  if (found.length === 0) return [];
+  const runs = [...text.matchAll(NAME_RUN)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+  return found.map((match) => {
+    const end = match.index + match[0].length;
+    return { start: runAround(runs, match.index)?.start ?? match.index, end: runAround(runs, end)?.end ?? end };
+  });
+};

package/src/company-names.ts

@@ -359,12 +359,33 @@ const relationBetween = (tally: Tally, other: Tally): CompanyRelation | undefine
   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/compound-head.ts

@@ -0,0 +1,25 @@
+import type { Token } from "./plugin.ts";
+
+const OPENING = new Set(["（", "("]);
+const CLOSING = new Set(["）", ")"]);
+
+const isTouching = (left: Token | undefined, right: Token | undefined): boolean =>
+  left !== undefined && right !== undefined && left.span.end === right.span.start;
+
+const isNounBefore = (token: Token, next: Token | undefined, suffixes: ReadonlySet<string>): next is Token =>
+  next?.pos === "NOUN" && isTouching(token, next) && !suffixes.has(next.surface);
+
+/** A noun alone in brackets that close onto a noun (卒業（見込）証明書): the brackets mark it optional inside one compound. */
+const isBracketedInCompound = (token: Token, tokens: readonly Token[], at: number, suffixes: ReadonlySet<string>): boolean => {
+  const [opening, closing] = [tokens[at - 1], tokens[at + 1]];
+  if (opening === undefined || closing === undefined) return false;
+  if (!OPENING.has(opening.surface) || !CLOSING.has(closing.surface) || !isTouching(opening, token) || !isTouching(token, closing)) return false;
+  return isNounBefore(closing, tokens[at + 2], suffixes);
+};
+
+/**
+ * Whether `token`, read at `at` in `tokens`, is a noun written onto the noun after it (取扱事業者), so official Japanese may
+ * drop its okurigana. A listed phrase suffix (割当て等) does not make a compound. `token` may be tokens[at] read as a noun.
+ */
+export const isCompoundHead = (token: Token, tokens: readonly Token[], at: number, suffixes: ReadonlySet<string>): boolean =>
+  token.pos === "NOUN" && (isNounBefore(token, tokens[at + 1], suffixes) || isBracketedInCompound(token, tokens, at, suffixes));

package/src/date-format.ts

@@ -115,9 +115,48 @@ const LINE_HEAD = /(?:^|\|)[\s>*_+-]*(?:\d+[.)]\s+)?$/u;
 /** 日付が行の頭（箇条書きの項目や表の升の頭）にあるか。 */
 export const opensLine = (text: string, offset: number): boolean => LINE_HEAD.test(text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset));
 
+/** 刻印のラベルと日付の間に来る字（更新日：、Last updated: ）。 */
+const STAMP_GAP = /[\s:：]/u;
+/** 末尾の、ラベルと日付の間の字を外した文字列。 */
+const withoutGap = (text: string): string => {
+  const chars = text.split("");
+  return chars.slice(0, chars.findLastIndex((char) => !STAMP_GAP.test(char)) + 1).join("");
+};
+
+/** 刻印のラベルの前に来てよい字。行の頭か、ページの部品を区切る空白と縦線（ページID：0014616 更新日：）。 */
+const STAMP_LEAD = /[\s|｜]/u;
+
+/**
+ * text が刻印のラベル word で終わり、ラベルが行の頭か区切りの後ろから始まる。文の中の語（この日付は公開：、The date:、
+ * 1Updated）は刻印のラベルではない。語彙表に書いたとおりの字で照らす。
+ */
+const endsWithLabel = (text: string, word: string): boolean => {
+  const start = text.length - word.length;
+  if (word === "" || start < 0 || !text.endsWith(word)) return false;
+  return start === 0 || STAMP_LEAD.test(text.charAt(start - 1));
+};
+
+/**
+ * 日付のすぐ前が、ページの更新日・公開日の刻印のラベル（更新日：2026年10月13日、Last updated: 2 October 2026）。
+ * 刻印は CMS が付ける付帯情報で、本文の日付の書き方（令和8年…）とは別の書き方をしてよい。
+ */
+export const stampedDate = (text: string, offset: number, stampLabels: readonly string[]): boolean => {
+  const before = withoutGap(text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset));
+  return stampLabels.some((label) => endsWithLabel(before, label));
+};
+
+type DateGroup = "head" | "body" | "stamp";
+
+const groupOf = (text: string, date: WrittenDate, stampLabels: readonly string[]): DateGroup => {
+  if (stampedDate(text, date.offset, stampLabels)) return "stamp";
+  return opensLine(text, date.offset) ? "head" : "body";
+};
+
+const GROUP_ORDER: readonly DateGroup[] = ["head", "body", "stamp"];
+
 /**
- * 行の頭の日付と、文の中の日付を分ける。予定表を 2026-10-16 で並べ、文では 14 October 2026 と書くのは使い分けで、混ざりではない。
- * 書き方はそれぞれの組の中でだけ比べる。
+ * 行の頭の日付と、文の中の日付と、更新日・公開日の刻印の日付を分ける。予定表を 2026-10-16 で並べ、文では 14 October 2026 と
+ * 書くのは使い分けで、混ざりではない。刻印のラベルは言語パッケージの語彙表（date-stamp-label）が渡す。書き方はそれぞれの組の中でだけ比べる。
  */
-export const dateGroups = (text: string, dates: readonly WrittenDate[]): WrittenDate[][] =>
-  [true, false].map((head) => dates.filter((date) => opensLine(text, date.offset) === head)).filter((group) => group.length > 0);
+export const dateGroups = (text: string, dates: readonly WrittenDate[], stampLabels: readonly string[] = []): WrittenDate[][] =>
+  GROUP_ORDER.map((group) => dates.filter((date) => groupOf(text, date, stampLabels) === group)).filter((group) => group.length > 0);

package/src/derived/count-per-period.ts

@@ -0,0 +1,28 @@
+import type { Span } from "../plugin.ts";
+import { overlapsAny, type SpanIndex } from "../compare/spans.ts";
+import type { DurationUnit } from "./date-arithmetic.ts";
+
+/** A word that names a period (週, 毎月, a week), where it is written beside the count, and the period's unit. */
+export type PeriodWord = { readonly word: string; readonly position: "before" | "after"; readonly unit: DurationUnit };
+
+/** The period words, and the named schedules in the document (週休2日制, 4週8休). */
+export type PerPeriodWords = { readonly periods: readonly PeriodWord[]; readonly schedules: SpanIndex };
+
+const UNIT_ORDER: readonly DurationUnit[] = ["day", "week", "month", "year"];
+
+/** A number or a counter just before the period word: 1年3か月 and 3か月10日 are one length written in two units, not a count per year or month. */
+const COUNTED = /[0-9０-９〇一二三四五六七八九十百千かヵヶカケ箇個]$/u;
+
+const endsWithPeriod = (before: string, word: string): boolean => before.endsWith(word) && !COUNTED.test(before.slice(0, before.length - word.length));
+
+const isBeside = (period: PeriodWord, before: string, after: string): boolean =>
+  period.position === "before" ? endsWithPeriod(before, period.word) : after.startsWith(period.word);
+
+/**
+ * A number with a unit of time that is not a length to add to a date: a count in each period (週3日、月10日、3 days a week) or a
+ * number inside the name of a work schedule (週休2日制の2日、4週8休の4週). A count is in a unit smaller than its period: 毎年1年間 is a
+ * year's length. before and after are the text next to the count, lower-cased.
+ */
+export const isCountPerPeriod = (count: Span & { readonly unit: DurationUnit }, before: string, after: string, words: PerPeriodWords): boolean =>
+  overlapsAny(words.schedules, count) ||
+  words.periods.some((period) => UNIT_ORDER.indexOf(count.unit) < UNIT_ORDER.indexOf(period.unit) && isBeside(period, before, after));

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 { nameSpansOf, 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,35 @@ export const notAcronymSpansOf = (words: NotationWords): NotAcronymSpans => {
     ...loneNumeralSpans(text),
     ...seriesLabelSpans(text),
     ...placeholderSpans(text, words.dateTimeUnits),
+    ...numeralWordSpans(text),
   ];
 };
+
+/**
+ * 略語として数えない範囲（書き方の範囲と、名前の中の範囲）を、言語パッケージの語彙表から組み立てる。wordsOf は語彙表の id から語を返す。
+ */
+export const lexiconNotationOf = (wordsOf: (id: string) => string[]): NotAcronymSpans => {
+  const notation = notAcronymSpansOf({
+    meridiem: wordsOf("meridiem"),
+    timeZones: wordsOf("time-zone"),
+    currencies: wordsOf("currency-code"),
+    usStates: wordsOf("us-state-code"),
+    emphasis: wordsOf("emphasis-word"),
+    divisions: wordsOf("numbered-division"),
+    abbreviatedLabels: wordsOf("abbreviated-label"),
+    honorifics: wordsOf("honorific"),
+    titles: wordsOf("name-title"),
+    dateTimeUnits: wordsOf("date-time-unit"),
+  });
+  const names = nameSpansOf({
+    legalForms: wordsOf("legal-form"),
+    companyForms: wordsOf("company-form"),
+    determiners: wordsOf("name-determiner"),
+    citationSeries: wordsOf("citation-series"),
+    carriers: wordsOf("carrier-name"),
+    namePrefixes: wordsOf("name-prefix"),
+    streetSuffixes: wordsOf("street-suffix"),
+    capitalPhrases: wordsOf("capital-phrase"),
+  });
+  return (text) => [...notation(text), ...names(text)];
+};