chaffjs 0.34.0 → 0.35.0

package/src/detectors/organisation-run.ts

@@ -0,0 +1,86 @@
+import type { Token } from "../plugin.ts";
+
+/** 組織の名前の前に立つ形（語彙表 organisation-form）と、組織や単位の名前を閉じる語（organisation-unit）。 */
+export type OrganisationWords = { readonly forms: readonly string[]; readonly units: readonly string[] };
+
+/** 区切りの前に要る字数。1 字なら、普通の語の一部（外部・本部・課題）と見分けられない。 */
+const MIN_BODY_LENGTH = 2;
+const KANJI = /[一-鿿]/u;
+
+const surfaceOf = (tokens: readonly Token[]): string => tokens.map((token) => token.surface).join("");
+const isNumber = (token: Token): boolean => token.features?.["NumType"] === "Card";
+const isProperPiece = (token: Token): boolean => token.pos === "PROPN" || token.features?.["NameType"] === "GeoUnit";
+
+/** covering の語が、隙間なく続いて並ぶときだけ、その語の並び。改行などで割れていれば読まない。 */
+const contiguous = (tokens: readonly Token[], covering: readonly number[]): Token[] | undefined => {
+  const run = covering.flatMap((index) => tokens.slice(index, index + 1));
+  const joined = run.every((token, at) => at === 0 || run[at - 1]?.span.end === token.span.start);
+  return run.length === covering.length && joined ? run : undefined;
+};
+
+/**
+ * 連なりのすぐ後ろの語が組織の語そのもの（幼稚園運営企画グループのグループ）なら、それも足した語の並び。
+ * 漢字でない組織の語は漢字の連なりの外にあるが、名前はそこで閉じる。
+ */
+const withClosingUnit = (tokens: readonly Token[], covering: readonly number[], units: readonly string[]): number[] => {
+  const next = (covering.at(-1) ?? -1) + 1;
+  const [last, closing] = [tokens[next - 1], tokens[next]];
+  const closes =
+    covering.length > 0 &&
+    last !== undefined &&
+    closing !== undefined &&
+    last.span.end === closing.span.start &&
+    !KANJI.test(closing.surface) &&
+    units.includes(closing.surface);
+  return closes ? [...covering, next] : [...covering];
+};
+
+/** 頭の、語の切れ目で終わる組織の形（国立研究開発法人）の語数。無ければ 0。 */
+const formLength = (run: readonly Token[], forms: ReadonlySet<string>): number =>
+  run.reduce((found, _, at) => (forms.has(surfaceOf(run.slice(0, at + 1))) ? at + 1 : found), 0);
+
+/** 頭の、固有名詞と地名の単位だけの並び（紀美野町、下神野地区、気象庁）の語数。固有名詞が無ければ 0。 */
+const properLength = (run: readonly Token[]): number => {
+  const length = run.findIndex((token) => !isProperPiece(token));
+  const stretch = length === -1 ? run.length : length;
+  return run.slice(0, stretch).some((token) => token.pos === "PROPN") ? stretch : 0;
+};
+
+/** 1 つの区切り（総務課、産業技術総合研究所）か。組織の語で閉じ、その前に 2 字以上の語があり、数を含まない。 */
+const isSegment = (part: readonly Token[], units: readonly string[]): boolean => {
+  const text = [...surfaceOf(part)];
+  const closing = units.filter((unit) => text.join("").endsWith(unit));
+  return !part.some(isNumber) && closing.some((unit) => text.length - [...unit].length >= MIN_BODY_LENGTH);
+};
+
+/**
+ * run を区切りだけに割ったときの区切りの数の最大。割れなければ 0。
+ * 後ろから、各位置から終わりまでを割れる数を一度ずつ決める（長い連なりでも語数の二乗で済む）。
+ */
+const segmentCount = (run: readonly Token[], units: readonly string[]): number => {
+  const counts = run.reduceRight<number[]>((after, _, start) => {
+    const best = run.slice(start).reduce((most, __, offset) => {
+      const end = start + offset + 1;
+      const rest = after[end - start - 1] ?? 0;
+      const closesRun = end === run.length;
+      return isSegment(run.slice(start, end), units) && (closesRun || rest > 0) ? Math.max(most, 1 + rest) : most;
+    }, 0);
+    return [best, ...after];
+  }, []);
+  return counts[0] ?? 0;
+};
+
+/**
+ * 漢字の連なりの語（covering: tokens の添字）が 1 つの組織の名前か。名前は書き手が変えられない。
+ * 法人格か地名・固有名詞で始まって組織の語で閉じるもの（国立研究開発法人産業技術総合研究所、紀美野町青少年育成町民会議）、
+ * または組織の語で閉じる区切りが 2 つ以上続くもの（国土交通省鉄道局総務課）。
+ * 組織の語で閉じない連なり（情報処理推進機構認定試験、総務課長）や、頭に名前の無い 1 区切り（個人情報保護法施行規則改正案検討会）は名前ではない。
+ */
+export const isOrganisationRun = (tokens: readonly Token[], covering: readonly number[], words: OrganisationWords): boolean => {
+  const run = contiguous(tokens, withClosingUnit(tokens, covering, words.units));
+  if (run === undefined || run.length === 0) return false;
+  const form = formLength(run, new Set(words.forms));
+  const head = form > 0 ? form : properLength(run);
+  const segments = segmentCount(run.slice(head), words.units);
+  return head > 0 ? segments >= 1 : segments >= 2;
+};

package/src/detectors/orthographic-variant.ts

@@ -7,8 +7,11 @@ import { nameSpans, touchesAny } from "../team-names.ts";
 import { furiganaSpans } from "../furigana.ts";
 import { acronymsIn, isCapitalsNotSpelling } from "../capitals-with-small.ts";
 import { isPartOfAddress } from "./address-word.ts";
+import { isInCapitalsPassage } from "../capitals-passage.ts";
+import { withoutCoinedNames } from "../coined-hyphen-name.ts";
 import { wholeWordRuns, type WholeWordRun } from "../whole-word-runs.ts";
 import { entriesForGenre } from "../lexicon-genres.ts";
+import { asNounWhereNominal } from "../nominal-stem.ts";
 
 /**
  * A word found in the document: where it is, which sentence it is in, its key and spelling, how it is written when that differs, and
@@ -41,6 +44,8 @@ const FUKUSHI = "hiragana-fukushi";
 const IDIOM = "orthographic-variant-idiom";
 /** Lexicon: words the tokenizer cuts in one spelling and not the other (お客様, お客 and さま). Each is read whole, keyed by its group. */
 const WHOLE_WORD = "orthographic-variant-whole-word";
+/** Lexicon: suffixes written onto a word that do not make a compound of it (割当て等, 引受け後): the word keeps its okurigana there. */
+const PHRASE_SUFFIX = "orthographic-variant-phrase-suffix";
 
 const patternsOf = (doc: ProseDocument, id: string, genre: string | undefined): string[] =>
   entriesForGenre(doc.lexicons[id] ?? [], genre).map((entry) => entry.pattern);
@@ -121,7 +126,12 @@ const isCutFromKatakana = ({ token, previous }: InContext): boolean =>
 const isCopulaReadAsVerb = ({ token, previous }: InContext): boolean =>
   token.pos === "VERB" && token.surface === "で" && previous !== undefined && previous.pos !== "ADP";
 
-type Skips = { readonly skip: ReadonlySet<string>; readonly idioms: ReadonlySet<string>; readonly wholeWords: ReadonlyMap<string, string> };
+type Skips = {
+  readonly skip: ReadonlySet<string>;
+  readonly idioms: ReadonlySet<string>;
+  readonly wholeWords: ReadonlyMap<string, string>;
+  readonly phraseSuffixes: ReadonlySet<string>;
+};
 
 const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefined => {
   const { token } = word;
@@ -156,13 +166,14 @@ const readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[
   const whole = runs.flatMap((run) => wholeWordOf(sentence, tokens, run, isOpen, skips.wholeWords));
   return [
     ...whole,
-    ...tokens.flatMap((token, at): Placed[] => {
+    ...tokens.flatMap((written, at): Placed[] => {
       if (inRun.has(at)) return [];
+      const next = tokens[at + 1];
+      const token = asNounWhereNominal(written, next, skips.phraseSuffixes);
       const key = readingKeyOf({ token, previous: tokens[at - 1], before: tokens[at - 2] }, skips);
       const local = token.span.start - sentence.span.start;
       if (key === undefined || token.lemma === undefined || !isOpen(local, local + token.surface.length)) return [];
-      const next = tokens[at + 1];
-      const compoundHead = token.pos === "NOUN" && next?.pos === "NOUN" && isTouching(token, next);
+      const compoundHead = token.pos === "NOUN" && next?.pos === "NOUN" && isTouching(token, next) && !skips.phraseSuffixes.has(next.surface);
       return [{ key, spelling: token.lemma, sentence, offset: token.span.start, compoundHead }];
     }),
   ];
@@ -260,7 +271,7 @@ const latinWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string
     const plain = word.toLowerCase().replaceAll("-", "");
     const end = match.index + word.length;
     if (plain.length < MIN_LATIN_KEY || !LOWER.test(word) || isCapitalsNotSpelling(word, acronyms) || skip.has(word.toLowerCase())) return [];
-    if (isPartOfAddress(sentence.text, match.index, end) || !isOpen(match.index, end)) return [];
+    if (isPartOfAddress(sentence.text, match.index, end) || !isOpen(match.index, end) || isInCapitalsPassage(sentence.text, match.index, end)) return [];
     return [{ key: `latin|${plain}`, spelling: latinSpelling(word), shown: word, sentence, offset: sentence.span.start + match.index }];
   });
 };
@@ -305,6 +316,7 @@ export const orthographicVariant: Detector = (doc, options): Finding[] => {
     skip: new Set([...patternsOf(doc, DISTINCT, options.genre), ...patternsOf(doc, FUKUSHI, options.genre)]),
     idioms: new Set(patternsOf(doc, IDIOM, options.genre)),
     wholeWords: new Map((doc.lexicons[WHOLE_WORD] ?? []).map((entry) => [entry.pattern, entry.group ?? entry.pattern])),
+    phraseSuffixes: new Set(patternsOf(doc, PHRASE_SUFFIX, options.genre)),
   };
   const names = doc.names ?? [];
   const placed: Place[] = [
@@ -314,7 +326,11 @@ export const orthographicVariant: Detector = (doc, options): Finding[] => {
   const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skips)));
   const katakana = placed.flatMap(({ sentence, isOpen }) => katakanaWords(sentence, isOpen));
   const runs = placed.flatMap(({ sentence, isOpen }) => katakanaRunWords(sentence, isOpen));
-  const latin = placed.flatMap(({ sentence, isOpen, readsLatin }) => (readsLatin ? latinWords(sentence, isOpen, skips.skip) : []));
+  const dictionary = doc.dictionary?.();
+  const latin = withoutCoinedNames(
+    placed.flatMap(({ sentence, isOpen, readsLatin }) => (readsLatin ? latinWords(sentence, isOpen, skips.skip) : [])),
+    (word) => dictionary?.has(word) ?? true,
+  );
   const odd = [reading, katakana, latin].flatMap((words) => oddSpellings(words, options.limit));
   const oddRuns = oddSpellings(runs, options.limit).filter(({ word }) => !odd.some((other) => coversOffset(word, other.word.offset)));
   const all = [...reading, ...katakana, ...runs, ...latin];

package/src/detectors/outline-label.ts

@@ -0,0 +1,48 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 行頭の、文字で振った見出しの番号（議事録の Z. の次の AA.、AB. … BZ.）。表計算の列名と同じく A〜Z の次は AA と進む。
+ * 略語ではない。行頭で . か ) が続き、その前か後の番号も同じ文書の行頭にあるときだけ番号と読む。1 か所だけの
+ * 行頭の大文字（IT. の説明、FAQ) の行）は略語のまま数える。そう読めた番号を区切りの名前の後ろで指す所（See Attachment AA）も
+ * 番号。区切りの名前は言語パッケージの語彙表から読む。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+const LABEL = /^[ \t]*(?<label>[A-Z]{1,3})[.)](?=[ \t]|$)/gmu;
+const ALPHABET = 26;
+const CODE_BEFORE_A = 64;
+
+/** A=1、Z=26、AA=27、AZ=52、BA=53。 */
+const positionOf = (label: string): number => [...label].reduce((total, letter) => total * ALPHABET + (letter.charCodeAt(0) - CODE_BEFORE_A), 0);
+
+type Label = { readonly text: string; readonly position: number; readonly span: Span };
+
+const labelsOf = (source: string): Label[] =>
+  [...source.matchAll(LABEL)].map((match) => {
+    const text = match.groups?.["label"] ?? "";
+    const start = match.index + match[0].indexOf(text);
+    return { text, position: positionOf(text), span: { start, end: start + text.length } };
+  });
+
+const lineLabels = (source: string): Label[] => {
+  const labels = labelsOf(source);
+  const positions = new Set(labels.map((label) => label.position));
+  return labels.filter(({ position }) => positions.has(position - 1) || positions.has(position + 1));
+};
+
+const referenceSpans = (source: string, labels: readonly Label[], divisions: readonly string[]): Span[] => {
+  const texts = [...new Set(labels.map((label) => label.text))];
+  if (texts.length === 0 || divisions.length === 0) return [];
+  const pattern = new RegExp(String.raw`(?<![A-Za-z0-9_])(?:${divisions.map(escapeRegExp).join("|")})\s+(?<label>${texts.join("|")})(?![A-Za-z0-9_&])`, "gu");
+  return [...source.matchAll(pattern)].map((match) => {
+    const end = match.index + match[0].length;
+    return { start: end - (match.groups?.["label"] ?? "").length, end };
+  });
+};
+
+/** 文書の中の、隣の番号と並んだ文字の番号と、それを区切りの名前の後ろで指す所の範囲。位置は文書の頭からの文字数。 */
+export const outlineLabelSpans = (source: string, divisions: readonly string[]): Span[] => {
+  const labels = lineLabels(source);
+  return [...labels.map((label) => label.span), ...referenceSpans(source, labels, divisions)];
+};

package/src/detectors/page-marker.ts

@@ -0,0 +1,26 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { LengthUnit } from "../plugin.ts";
+
+/**
+ * Page markers a converted print edition leaves inside a sentence ("( printed page 52044)", "[[Page 52044]]", 「－12－」).
+ * They are the page break, not the writer's words. The shapes come from the lexicon: "#" stands for the page number and a
+ * space for any run of spaces, none included. A marker touching a digit is part of a number (an address, 1－2－3).
+ */
+const NUMBER = "#";
+
+const TEMPLATE_PARTS: Readonly<Record<string, string>> = { [NUMBER]: String.raw`\p{Nd}+`, " ": String.raw`\s*` };
+
+const templatePattern = (template: string): string => [...template].map((char) => TEMPLATE_PARTS[char] ?? escapeRegExp(char)).join("");
+
+/** One pattern for every page marker the lexicon names, or undefined when it names none. */
+export const pageMarkerPattern = (templates: readonly string[]): RegExp | undefined =>
+  templates.length === 0 ? undefined : new RegExp(String.raw`(?<!\p{Nd})(?:${templates.map(templatePattern).join("|")})(?!\p{Nd})`, "gu");
+
+const sizeOf = (marker: string, unit: LengthUnit): number =>
+  unit === "word" ? marker.split(/\s+/u).filter((word) => word.length > 0).length : marker.replace(/\s+/gu, "").length;
+
+/** How much of a sentence its page markers take up, in the document's unit: their words, or their characters without spaces. */
+export const pageMarkerSize = (text: string, pattern: RegExp | undefined, unit: LengthUnit): number => {
+  if (pattern === undefined) return 0;
+  return [...text.matchAll(pattern)].map((match) => match[0]).reduce((size, marker) => size + sizeOf(marker, unit), 0);
+};

package/src/detectors/parallel-definition.ts

@@ -0,0 +1,64 @@
+import type { Lexicon, Sentence, Token } from "../plugin.ts";
+
+// 並べた定義: どの文も違う語を、同じ型（〜を指します、〜といいます）で定義する。同じ文末が続くのは型をそろえたからで、
+// 書き手の調子の繰り返しではない。
+
+const TRAILING_POS: ReadonlySet<string> = new Set(["PUNCT", "SYM"]);
+const TAIL_POS: ReadonlySet<string> = new Set(["AUX", "PART"]);
+
+export type DefinitionWords = { readonly frames: ReadonlySet<string>; readonly topics: ReadonlySet<string> };
+
+const patternsOf = (lexicon: Lexicon | undefined, group: string): ReadonlySet<string> =>
+  new Set((lexicon ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern));
+
+export const definitionWordsOf = (lexicon: Lexicon | undefined): DefinitionWords => ({
+  frames: patternsOf(lexicon, "frame"),
+  topics: patternsOf(lexicon, "topic"),
+});
+
+const surfacesOf = (tokens: readonly Token[]): string => tokens.map((token) => token.surface).join("");
+
+/** 述語（文末の助動詞の前の語）の位置。助動詞で終わらない文には無い。 */
+const predicateAt = (tokens: readonly Token[]): number | undefined => {
+  const last = tokens.findLastIndex((token) => !TRAILING_POS.has(token.pos));
+  const head = tokens.slice(0, last + 1).findLastIndex((token) => !TAIL_POS.has(token.pos));
+  return head > 0 && head < last ? head : undefined;
+};
+
+const PARTICLE_POS = "ADP";
+const TERM_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN"]);
+
+/** 定義の文が定義する語と、その型（を指す）。 */
+export type Definition = { readonly term: string; readonly frame: string };
+
+/** topic の助詞（は）より前。無ければ、述語の前の助詞の直前の名詞（〜を台風といいます の 台風）。 */
+const termOf = (tokens: readonly Token[], head: number, words: DefinitionWords): string => {
+  const topic = tokens.slice(0, head - 1).findIndex((token) => token.pos === PARTICLE_POS && words.topics.has(token.surface));
+  if (topic > 0) return surfacesOf(tokens.slice(0, topic));
+  const before = tokens[head - 2];
+  return before !== undefined && TERM_POS.has(before.pos) ? before.surface : "";
+};
+
+/** その文が定義する語と型。型の文（を指す、という）でなければ無い。 */
+export const definitionOf = (sentence: Sentence, words: DefinitionWords): Definition | undefined => {
+  const tokens = (sentence.tokens ?? []).filter((token) => token.surface.trim() !== "");
+  const head = predicateAt(tokens);
+  const particle = head === undefined ? undefined : tokens[head - 1];
+  const predicate = head === undefined ? undefined : tokens[head];
+  if (head === undefined || particle === undefined || predicate === undefined) return undefined;
+  const frame = `${particle.surface}${predicate.lemma ?? predicate.surface}`;
+  if (!words.frames.has(frame)) return undefined;
+  const term = termOf(tokens, head, words);
+  return term === "" ? undefined : { term, frame };
+};
+
+const isDefinition = (definition: Definition | undefined): definition is Definition => definition !== undefined;
+
+/** どの文も同じ型の定義で、定義する語がみな違う。 */
+export const isParallelDefinition = (sentences: readonly Sentence[], words: DefinitionWords): boolean => {
+  const definitions = sentences.map((sentence) => definitionOf(sentence, words));
+  if (!definitions.every(isDefinition)) return false;
+  const terms = new Set(definitions.map((definition) => definition.term));
+  const frames = new Set(definitions.map((definition) => definition.frame));
+  return terms.size === definitions.length && frames.size === 1;
+};

package/src/detectors/reference-text.ts

@@ -17,6 +17,7 @@ const inputOf = (doc: ProseDocument): ReferenceInput | undefined => {
       asides: patternsOf(doc, "reference-aside"),
       topicLinks: patternsOf(doc, "reference-topic-link"),
       vagueTopics: patternsOf(doc, "reference-topic-vague"),
+      listJoints: patternsOf(doc, "reference-list-joint"),
     },
   };
 };

package/src/detectors/registry/unfilled-placeholder.ts

@@ -1,4 +1,4 @@
 import type { Detector } from "../../plugin.ts";
-import { unfilledPlaceholder } from "../ai-phrasing.ts";
+import { unfilledPlaceholderOutsideTemplates } from "../unfilled-placeholder.ts";
 
-export const detector: Detector = unfilledPlaceholder;
+export const detector: Detector = unfilledPlaceholderOutsideTemplates;

package/src/detectors/registry/vague-density.ts

@@ -1,4 +1,4 @@
 import type { Detector } from "../../plugin.ts";
-import { vagueDensity } from "../lexicon.ts";
+import { vagueDensity } from "../vague-density.ts";
 
 export const detector: Detector = vagueDensity;

package/src/detectors/request-owner.ts

@@ -1,6 +1,6 @@
 // A request for an action (「資料をご確認ください」 "Please send the report.") with no deadline and no person or role,
 // in its own sentence or the next. The words come from the language's lexicons; the code only combines them.
-import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Span, StructureNode } from "../plugin.ts";
+import type { Detector, Finding, Lexicon, ProseDocument, Section, Sentence, Span, StructureNode } from "../plugin.ts";
 import { proseText } from "../measure.ts";
 import { comparableWords } from "./lexicon-match.ts";
 import { escapeRegExp } from "../orthography.ts";
@@ -15,6 +15,9 @@ export const REQUEST_LEXICONS = {
   owner: "request-owner",
   pointer: "request-pointer",
   offer: "request-offer",
+  timing: "request-timing",
+  invitation: "request-invitation",
+  contact: "request-contact",
 } as const;
 
 type Words = Readonly<Record<keyof typeof REQUEST_LEXICONS, readonly string[]>>;
@@ -32,6 +35,9 @@ const wordsOf = (doc: ProseDocument): Words => ({
   owner: patternsOf(doc.lexicons[REQUEST_LEXICONS.owner]),
   pointer: patternsOf(doc.lexicons[REQUEST_LEXICONS.pointer]),
   offer: patternsOf(doc.lexicons[REQUEST_LEXICONS.offer]),
+  timing: patternsOf(doc.lexicons[REQUEST_LEXICONS.timing]),
+  invitation: patternsOf(doc.lexicons[REQUEST_LEXICONS.invitation]),
+  contact: patternsOf(doc.lexicons[REQUEST_LEXICONS.contact]),
 });
 
 /** How far apart, in characters, the action word and the request ending may be: the action must be what is requested. */
@@ -57,16 +63,43 @@ export const containsAny = (text: string, patterns: readonly string[]): boolean
 
 const gapBetween = (left: Place, right: Place): number => Math.max(left.start - right.end, right.start - left.end, 0);
 
+/** An invitation verb right at the request ending (「ご相談ください」 "please come"): the reader may come, nothing is to be finished. */
+const INVITATION_REACH = 1;
+
+/** A comma or semicolon between an action and the invitation: the action is a request of its own (「申請書を提出し、会場へお越しください」). */
+const CLAUSE_BREAK = /[、，,;；]/u;
+
+/** A label and a colon (「電話：」 "Fax:"): a contact line, whose request is how to reach the writer. */
+const LABEL_COLON = /^\s*[:：]/u;
+
+/** Whether the action is what the invitation is for (「登録をしにお越しください」「入力用にご使用ください」), not a request beside it. */
+const invitedTo = (comparable: string, action: Place, invitation: Place): boolean => {
+  const [left, right] = action.start <= invitation.start ? [action, invitation] : [invitation, action];
+  return !CLAUSE_BREAK.test(comparable.slice(left.end, right.start));
+};
+
+const holdsContactLine = (text: string, words: Words): boolean => {
+  const comparable = comparableWords(text);
+  return placesOf(comparable, words.contact).some((label) => LABEL_COLON.test(comparable.slice(label.end)));
+};
+
 /**
  * A request for an action: an action word next to a request ending (「確認してください」「please send」), not a condition
  * (「ご不明な点があれば…ください」 is an offer), not an open offer to take the reader's questions (「ご質問はメールでお送りください」),
- * and not a pointer to where to read more (「詳細は資料をご確認ください」).
+ * not a pointer to where to read more (「詳細は資料をご確認ください」), not what an invitation is for (「登録をしにお越しください」),
+ * and not the way to reach the writer on a contact line (「ファックス番号：… 送信後、ご連絡ください」).
  * The action has to be close to the ending, or a noun like 検討会 or 履修登録 earlier in the sentence would make one.
  */
 export const isRequest = (text: string, words: Words): boolean => {
+  const comparable = comparableWords(text);
   const endings = placesOf(text, words.ending);
-  const asked = placesOf(text, words.action).some((action) => endings.some((ending) => gapBetween(action, ending) <= ACTION_REACH));
-  return asked && ![words.condition, words.offer, words.pointer].some((patterns) => containsAny(text, patterns));
+  const invitations = placesOf(text, words.invitation).filter((invitation) => endings.some((ending) => gapBetween(invitation, ending) <= INVITATION_REACH));
+  const asked = placesOf(text, words.action).some(
+    (action) =>
+      endings.some((ending) => gapBetween(action, ending) <= ACTION_REACH) && !invitations.some((invitation) => invitedTo(comparable, action, invitation)),
+  );
+  if (!asked || holdsContactLine(text, words)) return false;
+  return ![words.condition, words.offer, words.pointer].some((patterns) => containsAny(text, patterns));
 };
 
 const NAMED = new Set(["PROPN"]);
@@ -105,13 +138,16 @@ const holdsWord = (sentence: Sentence, patterns: readonly string[]): boolean =>
   return placesOf(comparable, patterns).some((place) => bounds === undefined || (bounds.starts.has(place.start) && bounds.ends.has(place.end)));
 };
 
-/** Whether a sentence says when (a date, a clock time, a deadline word) or who (a role; a name in the request itself). */
+/**
+ * Whether a sentence says when or who (a role). The request itself may also say when relative to something else
+ * (「提出いただく前に」 "before you submit") or name the person; the next sentence's timing or name may be about something else.
+ */
 const saysWhenOrWho = (sentence: Sentence, words: Words, dates: readonly Span[], isRequestItself: boolean): boolean =>
   datedWithin(dates, sentence.span) ||
   CLOCK.test(proseText(sentence)) ||
   holdsWord(sentence, words.deadline) ||
   holdsWord(sentence, words.owner) ||
-  (isRequestItself && namesSomeone(sentence));
+  (isRequestItself && (holdsWord(sentence, words.timing) || namesSomeone(sentence)));
 
 /** A paragraph break or a new list item between two sentences: the second does not continue the first. */
 const BREAK = /\n[^\S\n]*\n|\n[^\S\n]*(?:[-*+]|\d+[.)])[^\S\n]/u;
@@ -122,14 +158,41 @@ const continues = (source: string, sentence: Sentence, next: Sentence | undefine
 const dateSpans = (tree: StructureNode | undefined): Span[] =>
   tree === undefined ? [] : inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [node.span] : []));
 
-/** The request sentences with neither a deadline nor a person in them or in the sentence after, in the same paragraph or item. */
+/** A section's heading, read as a sentence so the deadline words match it the same way. */
+const headingOf = (section: Section): Sentence => ({
+  span: section.span,
+  text: section.heading,
+  ...(section.headingTokens === undefined ? {} : { tokens: section.headingTokens }),
+});
+
+/** The headings an offset sits under: its own section's, then each enclosing one's up to the title. */
+const enclosingHeadings = (sections: readonly Section[], offset: number): Sentence[] => {
+  const own = sections.findLastIndex((section) => section.span.start <= offset);
+  const chain = sections
+    .slice(0, own + 1)
+    .reduceRight<{ depth: number; found: Section[] }>(
+      (walk, section) => (section.depth < walk.depth ? { depth: section.depth, found: [...walk.found, section] } : walk),
+      { depth: Number.POSITIVE_INFINITY, found: [] },
+    ).found;
+  return chain.filter((section) => section.depth > 0 && section.heading.trim() !== "").map(headingOf);
+};
+
+/**
+ * A notice whose heading names its deadline (「見積提出期限：10月26日」「【随時受付】」): every request under it inherits it.
+ * A date alone in a heading is more often the day the notice was issued or the event it announces, so it is not enough.
+ */
+const underDeadlineHeading = (sections: readonly Section[], sentence: Sentence, words: Words): boolean =>
+  enclosingHeadings(sections, sentence.span.start).some((heading) => holdsWord(heading, words.deadline));
+
+/** The request sentences with neither a deadline nor a person in them, in the sentence after (same paragraph or item), or in a heading above. */
 export const ownerlessRequests = (doc: ProseDocument): Sentence[] => {
   const words = wordsOf(doc);
   const dates = dateSpans(doc.structure);
   return doc.sentences.filter((sentence, index) => {
     if (!isRequest(proseText(sentence), words) || saysWhenOrWho(sentence, words, dates, true)) return false;
     const next = doc.sentences[index + 1];
-    return !continues(doc.source, sentence, next) || !saysWhenOrWho(next, words, dates, false);
+    if (continues(doc.source, sentence, next) && saysWhenOrWho(next, words, dates, false)) return false;
+    return !underDeadlineHeading(doc.sections, sentence, words);
   });
 };
 

package/src/detectors/requirement-smell.ts

@@ -1,16 +1,20 @@
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
 import { entryCloses, entryIn, entryRanges } from "./lexicon-match.ts";
 import { openEndAt, openEndNames, type OpenEndNames } from "./open-end-names.ts";
+import { statesConcrete } from "./vague-deadline.ts";
 
 // Requirements smells (Femmer et al. 2017; Berry et al. 2003; ISO/IEC/IEEE 29148): a loophole, an open-ended list and
 // "and/or", in a sentence that states a requirement. What makes a sentence a requirement, and each smell's words, come
 // from the language's lexicons; this file knows neither language.
 
 const OPEN_END = "requirement-open-end";
+const LOOPHOLE = "requirement-loophole";
+const TIME = "time";
+const CONCRETE_DEADLINE = "concrete-deadline";
 
 /** Each smell: the lexicon of its words, and the finding's variant (the rule's messages). */
 const SMELLS = [
-  { lexicon: "requirement-loophole", variant: "loophole" },
+  { lexicon: LOOPHOLE, variant: "loophole" },
   { lexicon: OPEN_END, variant: "open-end" },
   { lexicon: "requirement-either", variant: "either" },
 ] as const;
@@ -43,9 +47,18 @@ const findingOf = (sentence: Sentence, entry: LexiconEntry, variant: string, off
   values: { matched: entry.pattern, offset },
 });
 
+/** A loophole about when (group: time) that the sentence bounds with a stated limit ("as soon as possible, but no later than two days after"). */
+const boundedInTime = (doc: ProseDocument, sentence: Sentence, entry: LexiconEntry, lexicon: string): boolean =>
+  lexicon === LOOPHOLE &&
+  entry.group === TIME &&
+  statesConcrete(
+    { start: sentence.span.start, text: sentence.text },
+    (doc.lexicons[CONCRETE_DEADLINE] ?? []).map((limit) => limit.pattern),
+  );
+
 /** Where the word stands as a smell. An open-end word inside a name the document gives (業務執行取締役等) is none; without tokens it cannot be told apart. */
 const smellAt = (doc: ProseDocument, sentence: Sentence, entry: LexiconEntry, lexicon: string, names: () => OpenEndNames): number | undefined => {
-  if (!entryIn(sentence, entry)) return undefined;
+  if (!entryIn(sentence, entry) || boundedInTime(doc, sentence, entry, lexicon)) return undefined;
   const tokenized = sentence.tokens !== undefined && (entry.tokens?.length ?? 0) > 0;
   return lexicon === OPEN_END && tokenized ? openEndAt(doc, sentence, entry, names()) : offsetOf(sentence, entry);
 };

package/src/detectors/sentence-length.ts

@@ -1,19 +1,26 @@
 import { lengthOf, proseText } from "../measure.ts";
 import type { Detector, DetectorOptions, Finding, LengthUnit, Sentence } from "../plugin.ts";
+import { pageMarkerPattern, pageMarkerSize } from "./page-marker.ts";
 
 type Measure = { readonly size: number; readonly limit: number; readonly variant?: string };
 
-/** 文書と違う言語の文（和文の中の英文）は、その言語の単位と上限で測る。rule がその言語の段を持たなければ文書のもので。 */
-const measureOf = (sentence: Sentence, unit: LengthUnit, options: DetectorOptions): Measure => {
+/**
+ * 文書と違う言語の文（和文の中の英文）は、その言語の単位と上限で測る。rule がその言語の段を持たなければ文書のもので。
+ * 印刷版のページの印（( printed page 52044)）は文の言葉ではないので数えない。
+ */
+const measureOf = (sentence: Sentence, unit: LengthUnit, options: DetectorOptions, markers: RegExp | undefined): Measure => {
   const embedded = sentence.embeddedLanguage;
   const limit = embedded === undefined ? undefined : options.embeddedLimits?.[embedded.id];
-  if (embedded === undefined || limit === undefined) return { size: lengthOf(sentence, unit), limit: options.limit };
+  if (embedded === undefined || limit === undefined) {
+    return { size: lengthOf(sentence, unit) - pageMarkerSize(proseText(sentence), markers, unit), limit: options.limit };
+  }
   return { size: lengthOf(sentence, embedded.lengthUnit), limit, variant: `embedded-${embedded.id}` };
 };
 
-export const sentenceLength: Detector = (doc, options): Finding[] =>
-  doc.sentences
-    .map((sentence) => ({ sentence, measure: measureOf(sentence, doc.lengthUnit, options) }))
+export const sentenceLength: Detector = (doc, options): Finding[] => {
+  const markers = pageMarkerPattern((options.lexicon ?? []).map((entry) => entry.pattern));
+  return doc.sentences
+    .map((sentence) => ({ sentence, measure: measureOf(sentence, doc.lengthUnit, options, markers) }))
     .filter(({ measure }) => measure.size > measure.limit)
     .map(({ sentence, measure }) => ({
       rule: "max-sentence-length",
@@ -24,3 +31,4 @@ export const sentenceLength: Detector = (doc, options): Finding[] =>
       values: { count: measure.size, limit: measure.limit, offset: sentence.span.start },
       ...(measure.variant === undefined ? {} : { variant: measure.variant }),
     }));
+};

package/src/detectors/sentence-rhythm.ts

@@ -1,5 +1,5 @@
 import { charLength, proseText } from "../measure.ts";
-import type { Detector, Finding } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
 
 /** 文が少ないと変動係数は当てにならない。ここを下回る文書は見ない。 */
 const MIN_SENTENCES = 8;
@@ -11,8 +11,12 @@ const coefficientOfVariation = (sizes: readonly number[]): number => {
   return Math.sqrt(variance) / mean;
 };
 
+/** 箇条書きの項目は揃えて書くのが正しい形なので、地の文の文だけを測る。 */
+const proseSentences = (doc: ProseDocument): readonly Sentence[] => doc.paragraphs.flatMap((paragraph) => paragraph.sentences);
+
 export const sentenceRhythm: Detector = (doc, options): Finding[] => {
-  const sizes = doc.sentences.map((sentence) => charLength(sentence));
+  const sentences = proseSentences(doc);
+  const sizes = sentences.map((sentence) => charLength(sentence));
   if (sizes.length < MIN_SENTENCES) return [];
   const spread = Math.round(coefficientOfVariation(sizes) * 100);
   if (spread >= options.limit) return [];
@@ -22,8 +26,8 @@ export const sentenceRhythm: Detector = (doc, options): Finding[] => {
       severity: "warning",
       line: 0,
       column: 0,
-      quote: doc.sentences[0] === undefined ? "" : proseText(doc.sentences[0]),
-      values: { count: spread, limit: options.limit, offset: doc.sentences[0]?.span.start ?? 0 },
+      quote: sentences[0] === undefined ? "" : proseText(sentences[0]),
+      values: { count: spread, limit: options.limit, offset: sentences[0]?.span.start ?? 0 },
     },
   ];
 };

package/src/detectors/series-label.ts

@@ -1,13 +1,22 @@
 /**
- * - で区切った文書番号のすぐ前の大文字の語（NIST SP 800-61 の SP、NSF 19-582、IEC 19757-2）。番号の一部で、略語ではない。
+ * - で区切った文書番号のすぐ前の大文字の語（NIST SP 800-61 の SP、NSF 19-582、IEC 19757-2、XRIN 0693-XC139、
+ * FR Doc. 2026-16371 の FR）。番号の一部で、略語ではない。
  * 空白で離して書くほかは、- で繋いだ識別子（AC-2）と同じ。番号の直前の 1 語だけで、その前の語（NIST）は略語のまま数える。
  * 区切りの無い番号（RFC 9110）、. で区切る版（SDK 3.1）、年の範囲（FY 2024-25）の前の語も略語のまま数える。
  */
 
 type Span = { readonly start: number; readonly end: number };
 
-const YEAR_RANGE = String.raw`(?:19|20)\d\d-\d`;
-const SERIES_LABEL = new RegExp(String.raw`(?<![A-Za-z0-9_&.-])[A-Z]+ (?!${YEAR_RANGE})(?<number>\d+(?:-\d+)+)[A-Za-z0-9]*(?![A-Za-z0-9_&-])`, "gu");
+/** 年の範囲（2024-25、1999-2000）。後ろが 3 桁や 5 桁の番号（FR Doc. 2026-16371）は年ではない。 */
+const YEAR_RANGE = String.raw`(?:19|20)\d\d-(?:(?:19|20)\d\d|\d\d)(?![A-Za-z0-9_&-])`;
+/** 語と番号の間に置く、点で終わる 2〜3 文字の略し（FR Doc. 2026-16371、EO No. 14028-1）。 */
+const NUMBER_WORD = String.raw`(?:[A-Z][a-z]{1,2}\. )?`;
+/** 2 つめからの区切りは、2 文字までの英字の頭を持てる（RIN の 0693-XC139）。英字の後ろは 3 桁以上の通し番号。 */
+const LATER_GROUP = String.raw`-(?:[A-Z]{1,2}\d{3,}|\d+)`;
+const SERIES_LABEL = new RegExp(
+  String.raw`(?<![A-Za-z0-9_&.-])[A-Z]+ ${NUMBER_WORD}(?!${YEAR_RANGE})(?<number>\d+(?:${LATER_GROUP})+)[A-Za-z0-9]*(?![A-Za-z0-9_&-])`,
+  "gu",
+);
 
 /**
  * 文書番号は長い通し番号を持つ（800-61、19757-2）。2 桁ずつの番号（BOD 25-01）は範囲・得点・日付（SRE 1-2、NFL 3-1、
@@ -23,7 +32,7 @@ const isRange = (groups: readonly string[]): boolean => {
 
 const isDocumentNumber = (number: string): boolean => {
   const groups = number.split("-");
-  return groups.some((group) => group.length >= SERIAL_DIGITS) && !isRange(groups);
+  return groups.some((group) => group.replace(/\D/gu, "").length >= SERIAL_DIGITS) && !isRange(groups);
 };
 
 /** 文の中の、番号と、その前の大文字の語の範囲。 */