chaffjs 0.33.0 → 0.35.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/per-unit-words.ts

@@ -0,0 +1,24 @@
+import type { ProseDocument, StructureNode } from "../plugin.ts";
+import { withPerUnits, type PerUnitMark, type PerUnitTemplate, type PerUnitWords } from "../facts/per-unit.ts";
+import { factValues, type FactValue } from "../facts/fact-values.ts";
+import { nameSpans } from "../compare/proper-nouns.ts";
+
+const marksOf = (doc: ProseDocument, id: string): PerUnitMark[] =>
+  (doc.lexicons[id] ?? []).map((entry): PerUnitMark => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
+
+/** 何あたりかの語: 決まった印（per-unit-mark）、型（fact-per-unit）、単位の語（rate-unit）、読まない百分率（percent-unit）、単価の列の見出し（unit-price-column）。 */
+const perUnitWordsOf = (doc: ProseDocument): PerUnitWords => ({
+  marks: marksOf(doc, "per-unit-mark"),
+  templates: (doc.lexicons["fact-per-unit"] ?? []).map((entry): PerUnitTemplate => ({ pattern: entry.pattern, position: entry.position ?? "before" })),
+  units: marksOf(doc, "rate-unit"),
+  percentUnits: (doc.lexicons["percent-unit"] ?? []).map((entry) => entry.pattern),
+  priceHeadings: (doc.lexicons["unit-price-column"] ?? []).map((entry) =>
+    entry.group === undefined ? { pattern: entry.pattern } : { pattern: entry.pattern, group: entry.group },
+  ),
+});
+
+/** 文書の値に、何あたりか（1kmあたり15円 の km）を付ける。 */
+export const perUnitsOf = <T extends FactValue>(doc: ProseDocument, values: readonly T[]): T[] => withPerUnits(doc.source, values, perUnitWordsOf(doc));
+
+/** 木の数量と日付と固有名詞（factValues）に、何あたりかを付けたもの。 */
+export const perUnitValues = (doc: ProseDocument, tree: StructureNode): FactValue[] => perUnitsOf(doc, factValues(tree, doc.source, nameSpans(doc)));

package/src/detectors/period-multiple-mismatch.ts

@@ -4,11 +4,9 @@
 // number-word (digit), and a range of counts is joined by range-connector or amount-range-word.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { periodMultipleMismatches, type PeriodMultipleWords } from "../structure/period-multiple.ts";
-import type { StatedAmount } from "../structure/stated-multiple.ts";
-import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
-import { amountsIn, formsOf } from "./currency-notation.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAround } from "./quote-around.ts";
+import { statedAmountsOf } from "./stated-amounts.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
   (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
@@ -27,23 +25,9 @@ const wordsOf = (doc: ProseDocument): PeriodMultipleWords => ({
   numberWords: numberWordsOf(doc),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
-  const scales = scaleWordsOf(doc);
-  return amountsIn(
-    text,
-    formsOf(doc),
-    scales.map((scale) => scale.word),
-  ).flatMap((amount) => {
-    const read = scaledAmountOf(text, amount, scales);
-    return read === undefined
-      ? []
-      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
-  });
-};
-
 export const periodMultipleMismatch: Detector = (doc): Finding[] => {
   const text = proseAndTablesOf(doc);
-  return periodMultipleMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+  return periodMultipleMismatches(text, statedAmountsOf(text, doc), wordsOf(doc)).map((issue) => ({
     rule: "period-multiple-mismatch",
     severity: "warning",
     line: 0,

package/src/detectors/reference-number-variant.ts

@@ -1,13 +1,14 @@
 // reference-number-variant: a document's own reference number written with two neighbouring characters swapped somewhere
 // else in the document, after a label of the same kind (reference-numbers.ts), or with no label where only one labelled
-// code swaps to it (unlabelled-references.ts); and the document's one vehicle plate written
+// code swaps to it (unlabelled-references.ts), or as the one code a product document is about (subject-codes.ts); and the document's one vehicle plate written
 // once with one character of its serial changed (vehicle-plates.ts).
-import { labelledReferenceNumbers, referenceVariants, type ReferenceNumber } from "../reference-numbers.ts";
+import { labelledReferenceNumbers, referenceVariants, type ReferenceNumber, type ReferenceVariant } from "../reference-numbers.ts";
 import { labelledPlates, plateVariants } from "../vehicle-plates.ts";
-import { tableCodes, tableLabelledCodes, unlabelledVariants } from "../unlabelled-references.ts";
+import { isCodeWith, tableCodes, tableLabelledCodes, unlabelledVariants } from "../unlabelled-references.ts";
+import { isSubjectCode, MIN_SUBJECT_DIGITS, subjectCodeVariants } from "../subject-codes.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAt } from "./structure-tree.ts";
-import type { Detector, Finding, OptionValue } from "../plugin.ts";
+import type { Detector, Finding, OptionValue, ProseDocument } from "../plugin.ts";
 
 const PLATE_SHAPES = "vehicle-plate";
 const SUBSTITUTED = "substituted";
@@ -25,6 +26,18 @@ const finding = (number: ReferenceNumber, other: ReferenceNumber, source: string
 /** Kinds a document lists many of (item codes): two labelled ones are two things, so only a code with no label is compared with them. */
 const listedKindsOf = (value: OptionValue | undefined): readonly string[] => (typeof value === "object" ? value : []);
 
+const TITLE_DEPTH = 1;
+
+/** The title as the source writes it, where it starts: the prose masks a heading's line. */
+const titleOf = (doc: ProseDocument): { start: number; text: string } | undefined => {
+  const title = doc.markup?.headings.find((heading) => heading.depth === TITLE_DEPTH);
+  return title === undefined ? undefined : { start: title.start, text: doc.source.slice(title.start, title.end) };
+};
+
+/** One finding per place, the first reading kept: a code may be read both as an unlabelled item code and as the document's own. */
+const firstAtEachOffset = (variants: readonly ReferenceVariant[]): ReferenceVariant[] =>
+  variants.filter((variant, index) => variants.findIndex((other) => other.number.offset === variant.number.offset) === index);
+
 export const referenceNumberVariant: Detector = (doc, options): Finding[] => {
   const labels = options.lexicon ?? [];
   if (labels.length === 0) return [];
@@ -36,9 +49,18 @@ export const referenceNumberVariant: Detector = (doc, options): Finding[] => {
   const listed = new Set(listedKindsOf(options.settings?.["listed_kinds"]));
   const withTables = proseAndTablesOf(doc);
   const labelled = [...numbers, ...tableLabelledCodes(withTables, labels)];
+  const subjectCodes = subjectCodeVariants({
+    prose: text,
+    title: titleOf(doc),
+    labels,
+    listed,
+    tabled: tableLabelledCodes(withTables, labels, isSubjectCode),
+    known: tableCodes(withTables, isCodeWith(MIN_SUBJECT_DIGITS)),
+  });
+  const unlabelled = firstAtEachOffset([...unlabelledVariants(text, labelled, tableCodes(withTables)), ...subjectCodes]);
   return [
     ...referenceVariants(numbers.filter((number) => !listed.has(number.label))).map(({ number, other }) => finding(number, other, doc.source)),
-    ...unlabelledVariants(text, labelled, tableCodes(withTables)).map(({ number, other }) => finding(number, other, doc.source)),
+    ...unlabelled.map(({ number, other }) => finding(number, other, doc.source)),
     ...plateVariants(plates).map(({ number, other }) => finding(number, other, doc.source, SUBSTITUTED)),
   ].toSorted((a, b) => Number(a.values["offset"]) - Number(b.values["offset"]));
 };

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/condition-toki.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { conditionToki } from "../condition-toki.ts";
+
+export const detector: Detector = conditionToki;

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

@@ -4,11 +4,9 @@
 // range of rent is joined by range-connector or amount-range-word.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { rentMultipleMismatches, type RentMultipleWords } from "../structure/rent-multiple.ts";
-import type { StatedAmount } from "../structure/stated-multiple.ts";
-import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
-import { amountsIn, formsOf } from "./currency-notation.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAround } from "./quote-around.ts";
+import { statedAmountsOf } from "./stated-amounts.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
   (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
@@ -30,23 +28,9 @@ const wordsOf = (doc: ProseDocument): RentMultipleWords => ({
   numberWords: numberWordsOf(doc),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
-  const scales = scaleWordsOf(doc);
-  return amountsIn(
-    text,
-    formsOf(doc),
-    scales.map((scale) => scale.word),
-  ).flatMap((amount) => {
-    const read = scaledAmountOf(text, amount, scales);
-    return read === undefined
-      ? []
-      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
-  });
-};
-
 export const rentMultipleMismatch: Detector = (doc): Finding[] => {
   const text = proseAndTablesOf(doc);
-  return rentMultipleMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+  return rentMultipleMismatches(text, statedAmountsOf(text, doc), wordsOf(doc)).map((issue) => ({
     rule: "rent-multiple-mismatch",
     severity: "warning",
     line: 0,

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/row-sentence-amounts.ts

@@ -4,15 +4,8 @@ import { factValues, type FactValue } from "../facts/fact-values.ts";
 import { cellsOf, tablesOf } from "../facts/table-facts.ts";
 import { scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
 import { withoutEdgeMarks } from "../facts/trim-marks.ts";
-import {
-  periodOf,
-  rowSentenceConflicts,
-  type Amount,
-  type AmountRow,
-  type PeriodMark,
-  type SubjectSentence,
-  type SubjectWords,
-} from "../facts/row-sentence-amounts.ts";
+import { rowSentenceConflicts, type Amount, type AmountRow, type SubjectSentence, type SubjectWords } from "../facts/row-sentence-amounts.ts";
+import { perUnitsOf } from "./per-unit-words.ts";
 import { linesOf, type Line } from "../structure/lines.ts";
 import { quoteAt } from "./structure-tree.ts";
 
@@ -57,19 +50,11 @@ const subjectWordsOf = (doc: ProseDocument): SubjectWords => ({
   conditions: patternsOf(doc, "fact-amount-condition"),
 });
 
-const periodMarksOf = (doc: ProseDocument): PeriodMark[] =>
-  (doc.lexicons["per-unit-mark"] ?? []).map((entry): PeriodMark => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
-
-/** 金額: 通貨の語彙表の印を単位に書いた数量。前後に期間あたりの印があれば、その期間も。 */
+/** 金額: 通貨の語彙表の印を単位に書いた数量。何あたりの金額（日額、1kmあたり）は、その単位も。 */
 const amountsOf = (doc: ProseDocument, tree: StructureNode): Amount[] => {
   const currencies = new Set(patternsOf(doc, "currency-notation").map((pattern) => pattern.normalize("NFKC")));
-  const marks = periodMarksOf(doc);
-  return factValues(tree, doc.source, nameSpans(doc))
-    .filter((value) => value.kind === "quantity" && currencies.has(value.unit))
-    .map((value): Amount => {
-      const period = periodOf(doc.source, value, marks);
-      return period === undefined ? value : { ...value, period };
-    });
+  const amounts = factValues(tree, doc.source, nameSpans(doc)).filter((value) => value.kind === "quantity" && currencies.has(value.unit));
+  return perUnitsOf(doc, amounts);
 };
 
 /** 表の行の金額と、その行の見出しを主語にした文の金額の食い違い。名前付きの値として読めた文の値は、ほかの読みが比べる。 */

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);
 };
 
 /** 文の中の、番号と、その前の大文字の語の範囲。 */