chaffjs 0.25.0 → 0.26.0

package/src/detectors/quote-without-source.ts

@@ -0,0 +1,90 @@
+// A quotation the text gives to someone (「…」と述べている, according to X, "…") in a paragraph that names no source for it:
+// no link, no footnote or numbered citation, no year in brackets. Whether the words are really that person's is for
+// `chaff cite` against the source; this only says that there is nothing to check them against. The words that give a
+// quotation to someone come from the language package's word list quote-attribution. Pure.
+import { QUOTATION_MARKS, quotedSpans } from "../quoted-span.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument } from "../plugin.ts";
+
+export type QuoteText = { readonly start: number; readonly text: string };
+
+export type QuoteParagraph = { readonly source: string; readonly sentences: readonly QuoteText[] };
+
+export type UnsourcedQuote = { readonly offset: number; readonly quote: string };
+
+/** Shorter than this, a quotation is a term or a label (「保存」, "Save"), not someone's words. */
+const MIN_QUOTE_CHARS = 10;
+
+/**
+ * A link, a bare URL, a footnote mark, a numbered citation ([3]) or a year that ends a bracket as a citation's does: alone
+ * ((1975), （1999年）), after a comma (（架空の本、1975年）) or after a name ((Brooks 1975)). Not (port 2000).
+ */
+const SOURCE_MARKS = [
+  /\]\(/u,
+  /https?:\/\//u,
+  /\[\^[^\]\s]+\]/u,
+  /\[\d{1,3}(?:[,，、–-]\s*\d{1,3})*\]/u,
+  /[（(](?:1[5-9]|20)\d\d[a-z]?年?[）)]/u,
+  /[（(][^（）()\n]*[,、，]\s*(?:1[5-9]|20)\d\d[a-z]?年?[）)]/u,
+  /[（(]\p{Lu}[^（）()\n]*\s(?:1[5-9]|20)\d\d[a-z]?[）)]/u,
+];
+
+/** How far before a quotation a cue may end ("According to the study, “…”", 先輩によれば「…」). */
+const CUE_REACH_BEFORE = 40;
+/** How far after a quotation a cue may start: a space ("“…,” said"), or none (「…」と述べた, not 「…」などと書く). */
+const CUE_REACH_AFTER = 1;
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+
+const namesSource = (paragraph: string): boolean => SOURCE_MARKS.some((mark) => mark.test(paragraph));
+
+const escaped = (word: string): string => word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/**
+ * Where the cue stands in the sentence, ignoring case, in the sentence's own positions (lowercasing first would move them:
+ * İ becomes two units). An English cue is not read inside a longer word (says in essays).
+ */
+const cueStarts = (text: string, cue: string): number[] => {
+  if (cue === "") return [];
+  return [...text.matchAll(new RegExp(escaped(cue), "giu"))]
+    .map((match) => match.index)
+    .filter((at) => !LATIN.test(cue) || (!LETTER.test(text.charAt(at - 1)) && !LETTER.test(text.charAt(at + cue.length))));
+};
+
+type Quoted = { readonly start: number; readonly end: number };
+
+/** A cue just before the quotation's opening mark, or just after its closing mark. position says which side it may stand on. */
+const isAttributed = (text: string, quoted: Quoted, cues: readonly LexiconEntry[]): boolean =>
+  cues.some((cue) =>
+    cueStarts(text, cue.pattern).some((at) => {
+      const before = cue.position !== "after" && at + cue.pattern.length <= quoted.start - 1 && at + cue.pattern.length >= quoted.start - 1 - CUE_REACH_BEFORE;
+      const after = cue.position !== "before" && at >= quoted.end + 1 && at <= quoted.end + 1 + CUE_REACH_AFTER;
+      return before || after;
+    }),
+  );
+
+const quotesIn = (sentence: QuoteText, cues: readonly LexiconEntry[]): UnsourcedQuote[] => {
+  return quotedSpans(sentence.text, QUOTATION_MARKS)
+    .filter((span) => [...sentence.text.slice(span.start, span.end).trim()].length >= MIN_QUOTE_CHARS && isAttributed(sentence.text, span, cues))
+    .map((span) => ({ offset: sentence.start + span.start, quote: sentence.text.slice(span.start, span.end).trim() }));
+};
+
+/** Each quotation given to someone, in a paragraph that names no source. cues: the word list quote-attribution. */
+export const unsourcedQuotes = (paragraphs: readonly QuoteParagraph[], cues: readonly LexiconEntry[]): UnsourcedQuote[] =>
+  paragraphs.filter((paragraph) => !namesSource(paragraph.source)).flatMap((paragraph) => paragraph.sentences.flatMap((sentence) => quotesIn(sentence, cues)));
+
+export const quoteWithoutSource: Detector = (doc: ProseDocument): Finding[] =>
+  unsourcedQuotes(
+    doc.paragraphs.map((paragraph) => ({
+      source: doc.source.slice(paragraph.span.start, paragraph.span.end),
+      sentences: paragraph.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text })),
+    })),
+    doc.lexicons["quote-attribution"] ?? [],
+  ).map((hit) => ({
+    rule: "quote-without-source",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: hit.quote,
+    values: { quote: hit.quote, offset: hit.offset },
+  }));

package/src/detectors/reference-text.ts

@@ -12,7 +12,7 @@ const inputOf = (doc: ProseDocument): ReferenceInput | undefined => {
   return {
     source: doc.source,
     references: inDocumentOrder(tree).filter((node) => node.kind === "reference" && node.attrs["document"] === undefined),
-    targetOf: referenceResolver(tree),
+    targetOf: referenceResolver(tree, doc.source),
     words: {
       asides: patternsOf(doc, "reference-aside"),
       topicLinks: patternsOf(doc, "reference-topic-link"),

package/src/detectors/registry/party-role-name.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { partyRoleName } from "../party-role-name.ts";
+
+export const detector: Detector = partyRoleName;

package/src/detectors/registry/quote-without-source.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { quoteWithoutSource } from "../quote-without-source.ts";
+
+export const detector: Detector = quoteWithoutSource;

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

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

package/src/detectors/run-in-label.ts

@@ -0,0 +1,60 @@
+import type { Span } from "../plugin.ts";
+
+/** 行の頭の引用の印と字下げ、箇条の印、チェックボックス。この後ろで太字が開く。 */
+const QUOTE_INDENT = /^(?:[ \t]*>)*[ \t]*/u;
+const ITEM_MARKER = /^(?:[-*+]|\d{1,9}[.)])[ \t]+/u;
+const TASK_BOX = /^\[[ xX]\][ \t]+/u;
+const BOLD = /^(?:\*\*|__)$/u;
+
+type Opening = { readonly marker: string; readonly item: boolean };
+
+/** 行の頭から文の始まりまで（before）が、印の後ろで開いた太字だけか。 */
+const openingOf = (before: string): Opening | undefined => {
+  const unquoted = before.replace(QUOTE_INDENT, "");
+  const rest = unquoted.replace(ITEM_MARKER, "").replace(TASK_BOX, "");
+  return BOLD.test(rest) ? { marker: rest, item: rest.length < unquoted.length } : undefined;
+};
+
+/** 段落の切れ目になる前の行: 空の行（引用の中の空の行も）と見出し。 */
+const BLOCK_BEFORE = /^(?:[ \t]*>)*[ \t]*(?:#.*)?$/u;
+
+/** 文の終わりの句読点。札の句点を太字の外に書く形（**速く書ける**。）もある。 */
+const STOP = /[。．.！？!?]$/u;
+
+const lineAround = (source: string, offset: number): { readonly start: number; readonly end: number } => {
+  const end = source.indexOf("\n", offset);
+  return { start: source.lastIndexOf("\n", offset - 1) + 1, end: end === -1 ? source.length : end };
+};
+
+/** 太字が閉じる位置。文の直後か、文末の句読点の直前。 */
+const closingOf = (source: string, span: Span, marker: string): number | undefined => {
+  if (source.startsWith(marker, span.end)) return span.end;
+  const stop = STOP.exec(source.slice(span.start, span.end))?.[0];
+  const before = stop === undefined ? -1 : span.end - stop.length - marker.length;
+  return before > span.start && source.startsWith(marker, before) ? before : undefined;
+};
+
+/** 文全体を一つの太字が包むなら、太字と文の後ろの位置。途中で閉じる太字（**a** と **b。**）は包んでいない。 */
+const closedAt = (source: string, span: Span, marker: string): number | undefined => {
+  const closing = closingOf(source, span, marker);
+  if (closing === undefined || source.slice(span.start, closing).includes(marker)) return undefined;
+  return Math.max(closing + marker.length, span.end);
+};
+
+/** 行の頭が段落の頭か。箇条の印のある行は項目の頭。折り返した段落の続きの行（前の行に文がある）は頭ではない。 */
+const opensBlock = (source: string, lineStart: number, item: boolean): boolean => {
+  if (item || lineStart === 0) return true;
+  return BLOCK_BEFORE.test(source.slice(source.lastIndexOf("\n", lineStart - 2) + 1, lineStart - 1));
+};
+
+/**
+ * 行の頭の太字だけでできた文で、同じ行に続きがあるもの（「- **速く書ける。** 細かな文法を覚えなくても書けます。」の「速く書ける。」）。
+ * 項目や段落の札で、見出しと同じく本文の文ではない。太字だけの行（「**注意してください。**」）は札ではなく文。
+ */
+export const isRunInLabel = (source: string, span: Span): boolean => {
+  const line = lineAround(source, span.start);
+  const opening = openingOf(source.slice(line.start, span.start));
+  if (opening === undefined || !opensBlock(source, line.start, opening.item)) return false;
+  const after = closedAt(source, span, opening.marker);
+  return after !== undefined && after <= line.end && /\S/u.test(source.slice(after, line.end));
+};

package/src/detectors/sentence-counts.ts

@@ -73,12 +73,20 @@ export const sentenceConjunctiveCount: Detector = (doc, options): Finding[] => {
 
 type Opened = { readonly sentence: Sentence; readonly opener: string | undefined };
 
-const openerOf = (sentence: Sentence, lexicon: Lexicon): string | undefined => lexicon.find((entry) => entryOpens(sentence, entry))?.pattern;
+/**
+ * The lexicon's word the sentence opens with, unless it opens with one of `notOpeners`: "This Agreement" and "This section"
+ * point at the document itself, not back at the sentence before.
+ */
+const openerOf = (sentence: Sentence, lexicon: Lexicon, notOpeners: Lexicon): string | undefined =>
+  notOpeners.some((entry) => entryOpens(sentence, entry)) ? undefined : lexicon.find((entry) => entryOpens(sentence, entry))?.pattern;
+
+/** The phrases that open a sentence with a lexicon word but do not point back (this-document references). */
+export const NOT_OPENER_LEXICON = "demonstrative-not-opener";
 
 /** Runs of consecutive sentences in one paragraph that each open with a lexicon word. */
-export const openerRuns = (sentences: readonly Sentence[], lexicon: Lexicon): Opened[][] =>
+export const openerRuns = (sentences: readonly Sentence[], lexicon: Lexicon, notOpeners: Lexicon = []): Opened[][] =>
   sentences
-    .map((sentence) => ({ sentence, opener: openerOf(sentence, lexicon) }))
+    .map((sentence) => ({ sentence, opener: openerOf(sentence, lexicon, notOpeners) }))
     .reduce<Opened[][]>(
       (runs, opened) => {
         if (opened.opener === undefined) return [...runs, []];
@@ -104,8 +112,9 @@ const runFinding = (run: readonly Opened[], options: DetectorOptions): Finding =
 /** More than limit sentences in a row within one paragraph, each opening with a word from the lexicon (これ, その). */
 export const openerRun: Detector = (doc, options): Finding[] => {
   const lexicon = options.lexicon ?? [];
+  const notOpeners = doc.lexicons[NOT_OPENER_LEXICON] ?? [];
   return doc.paragraphs.flatMap((paragraph) =>
-    openerRuns(paragraph.sentences, lexicon)
+    openerRuns(paragraph.sentences, lexicon, notOpeners)
       .filter((run) => run.length > options.limit)
       .map((run) => runFinding(run, options)),
   );

package/src/detectors/sentence-ending.ts

@@ -1,6 +1,7 @@
 import { endingTokens, isClosed } from "../sentence-shape.ts";
 import { enumeratedRuns, enumeratorStarts, numberedStarts } from "./enumerated-runs.ts";
 import { continuesInto, groupOf, registerOf, slipsOf, type Register } from "./register.ts";
+import { isRunInLabel } from "./run-in-label.ts";
 import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } from "../plugin.ts";
 
 /**
@@ -8,7 +9,7 @@ import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } f
  *
  * どちらが正しいかは決めない。決めると、方針の違う書き手にそのまま無視される。
  * 見るのは文書の中での一貫性だけで、少数派のほうを指摘する。spec §12.3 の方針を日本語にも。
- * 終止符で終わらないもの（見出しの下の `MaaSサービス` のような名前だけの行）は文として数えない。
+ * 終止符で終わらないもの（見出しの下の `MaaSサービス` のような名前だけの行）と、項目や段落の頭の太字の札（**速く書ける。**）は文として数えない。
  */
 type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
@@ -35,7 +36,7 @@ export const judgedSentences = (doc: ProseDocument, polite: readonly LexiconEntr
   const neutral = doc.lexicons["neutral-ending"] ?? [];
   const lists = doc.lists.map((list) => list.span);
   const found = doc.sentences.flatMap((sentence, index): { sentence: Sentence; register: Register }[] => {
-    if (!isClosed(sentence) || continuesInto(sentence, doc.sentences[index + 1])) return [];
+    if (!isClosed(sentence) || continuesInto(sentence, doc.sentences[index + 1]) || isRunInLabel(doc.source, sentence.span)) return [];
     const register = registerOfSentence(sentence, polite, neutral);
     return register === undefined ? [] : [{ sentence, register }];
   });

package/src/detectors/structure-tree.ts

@@ -4,6 +4,7 @@ import { numberingBreaks } from "../structure/numbering.ts";
 import { weekdayMismatches } from "../structure/weekday.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
+import { proseTotalMismatches } from "../structure/prose-total.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
@@ -104,15 +105,35 @@ const amountsOf = (tree: NonNullable<ProseDocument["structure"]>): Amount[] =>
     node.kind === "quantity" ? [{ offset: node.span.start, end: node.span.end, value: Number(node.attrs["value"]), unit: String(node.attrs["unit"]) }] : [],
   );
 
-/** 合計の行が、上の金額の和と合わない。合計の語は言語パッケージの語彙表（total-label）から取る。 */
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/** 合計の行と内訳の行、文の中の合計と内訳。同じ金額は一度だけ言う。 */
+const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["structure"]>): StructureIssue[] => {
+  const amounts = amountsOf(tree);
+  const lines = totalMismatches(doc.source, amounts, patternsOf(doc, "total-label"));
+  const words = {
+    totals: patternsOf(doc, "total-phrase"),
+    breakdowns: patternsOf(doc, "breakdown-phrase"),
+    discounts: patternsOf(doc, "discount-word"),
+    joiners: patternsOf(doc, "breakdown-gap-joiner"),
+  };
+  const prose = proseTotalMismatches(
+    doc.source,
+    doc.sentences.map((sentence) => sentence.span),
+    amounts,
+    words,
+  );
+  return [...lines, ...prose.filter((issue) => !lines.some((line) => line.offset === issue.offset))];
+};
+
+/**
+ * 合計が内訳の和と合わない。表と箇条書きの合計の行（合計の語は total-label）と、文の中の合計（total-phrase、breakdown-phrase）。
+ * 語は言語パッケージの語彙表から取る。
+ */
 export const totalMismatch: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : totalMismatches(
-        doc.source,
-        amountsOf(doc.structure),
-        (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern),
-      ).map((issue) => ({
+    : totalIssues(doc, doc.structure).map((issue) => ({
         rule: "total-mismatch",
         severity: "error",
         line: 0,
@@ -127,6 +148,7 @@ const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   closers: (doc.lexicons["range-closer"] ?? []).map((entry) => entry.pattern),
   frames: (doc.lexicons["range-frame"] ?? []).flatMap((entry) => rangeFrameOf(entry.pattern) ?? []),
   changes: (doc.lexicons["date-change-word"] ?? []).map((entry) => entry.pattern),
+  weekdays: (doc.lexicons["weekday"] ?? []).map((entry) => entry.pattern),
 });
 
 /** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */

package/src/detectors/unbalanced-bracket.ts

@@ -108,25 +108,40 @@ export const bracketProblems = (text: string): BracketProblem[] => {
   return [...scan.problems, ...scan.open.map(unclosedOf)].toSorted((left, right) => left.offset - right.offset);
 };
 
-/** sorted（昇順・重ならない）のどれかが offset を含むか。何万もの字の節があっても、URL ごとに全部をなめない。 */
-const coversOffset = (sorted: readonly Span[], offset: number): boolean => {
-  const span = sorted[firstEndingAfter(sorted, offset)];
-  return span !== undefined && span.start <= offset;
+/** sorted（昇順・接しもしない）で、offset の後ろの最初の境目: offset を含む範囲の終わりか、次の範囲の始まり。 */
+const borderAfter = (sorted: readonly Span[], offset: number): number => {
+  const next = sorted[firstEndingAfter(sorted, offset)];
+  if (next === undefined) return Number.POSITIVE_INFINITY;
+  return next.start <= offset ? next.end : next.start;
 };
 
+/** 覆いの中で URL そのものが終わる位置。ASCII でない字か、コードと字のまま見える範囲の境目（「`https://…`）」の「`」）で終わる。 */
+const urlProperEnd = (written: string, start: number, readable: readonly Span[]): number => {
+  const nonAscii = written.search(/[^\p{ASCII}]/u);
+  return Math.min(nonAscii === -1 ? written.length : nonAscii, borderAfter(readable, start) - start, written.length);
+};
+
+/** sorted（昇順・重ならない）のうち range に重なるものを、range の中に切り詰めたもの。何万もの字の節があっても、URL ごとに全部をなめない。 */
+const clippedTo = (sorted: readonly Span[], range: Span): Span[] =>
+  sorted
+    .slice(firstEndingAfter(sorted, range.start), firstEndingAfter(sorted, range.end) + 1)
+    .filter((span) => span.start < range.end)
+    .map((span) => ({ start: Math.max(span.start, range.start), end: Math.min(span.end, range.end) }));
+
 /**
  * 本文（prose）では URL を覆うが、覆いは空白まで取るので、URL の直後に続けて書いた字（「（https://example.jp/）」の「）」）まで消える。
- * 読み手には見えている字なので、ASCII でない字から先を元に戻す。コードの中の URL（texts の外）は戻さない。
+ * 読み手には見えている字なので、URL が終わった後ろの、字のまま見える範囲（texts）を元に戻す。コードの中の URL の後ろも同じ。
  */
 export const withRunOnRestored = (prose: string, source: string, texts: readonly Span[]): string => {
-  const readable = mergeSpans(texts, false);
+  const readable = mergeSpans(texts, true);
   const parts: string[] = [];
   const cursor = { at: 0 };
   [...source.matchAll(BARE_URL)].forEach((match) => {
-    const tail = match[0].search(/[^\p{ASCII}]/u);
-    if (tail === -1 || !coversOffset(readable, match.index)) return;
-    parts.push(prose.slice(cursor.at, match.index + tail), source.slice(match.index + tail, match.index + match[0].length));
-    cursor.at = match.index + match[0].length;
+    const tail = { start: match.index + urlProperEnd(match[0], match.index, readable), end: match.index + match[0].length };
+    clippedTo(readable, tail).forEach((span) => {
+      parts.push(prose.slice(cursor.at, span.start), source.slice(span.start, span.end));
+      cursor.at = span.end;
+    });
   });
   parts.push(prose.slice(cursor.at));
   return parts.join("");

package/src/detectors/vague-deadline.ts

@@ -0,0 +1,132 @@
+// A time limit a contract leaves to the reader (速やかに, 遅滞なく, promptly, within a reasonable time) where the same
+// contract writes most of its limits as numbers (7日以内, within thirty days): who decides whether 速やかに was met?
+// Which way to write limits is the drafter's choice; only the minority in one document is pointed at. A sentence that
+// also gives a number of days (速やかに、遅くとも7日以内に) has a deadline, and a sentence that grants a right (may
+// promptly suspend, 速やかに解除することができる) sets no deadline. The words come from the language package's word
+// lists: vague-deadline, concrete-deadline (a stated limit: 日以内, "within … days") and deadline-permission. Pure.
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument } from "../plugin.ts";
+
+export type VagueDeadline = { readonly offset: number; readonly word: string };
+
+type Text = { readonly start: number; readonly text: string };
+
+type Hit = { readonly at: number; readonly word: string };
+
+/** What the three word lists give the decision. */
+export type DeadlineWords = {
+  readonly vague: readonly string[];
+  /** A phrase, or a frame "within … days": the second part within FRAME_REACH characters after the first. */
+  readonly concrete: readonly string[];
+  /** A right, not a duty: a word anywhere in the sentence, or (position: after) the sentence's ending. */
+  readonly permissions: readonly LexiconEntry[];
+};
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+const FRAME = "…";
+/** How far after "within" the unit of a frame may come: "within fourteen (14) business days". */
+const FRAME_REACH = 30;
+const SENTENCE_MARKS = new Set(["。", "．", ".", "!", "?", "！", "？"]);
+
+/** The sentence without its closing marks and spaces. */
+const withoutEnding = (text: string): string => {
+  const chars = [...text.trimEnd()];
+  const last = chars.findLastIndex((char) => !SENTENCE_MARKS.has(char) && char.trim() !== "");
+  return chars.slice(0, last + 1).join("");
+};
+
+/** An English word is not read inside a longer one (promptly in unpromptly, may in mayor). */
+const isWordAt = (text: string, word: string, at: number): boolean =>
+  !LATIN.test(word) || (!LETTER.test(text.charAt(at - 1)) && !LETTER.test(text.charAt(at + word.length)));
+
+const indexesOf = (text: string, word: string): number[] => {
+  const found: number[] = [];
+  if (word === "") return found;
+  let at = text.indexOf(word);
+  while (at !== -1) {
+    found.push(at);
+    at = text.indexOf(word, at + word.length);
+  }
+  return found;
+};
+
+const wordIn = (lower: string, word: string): boolean => indexesOf(lower, word.toLowerCase()).some((at) => isWordAt(lower, word, at));
+
+/** A phrase, or a frame whose second part follows its first within reach. */
+const concreteIn = (lower: string, entry: string): boolean => {
+  const [lead = "", tail, ...rest] = entry
+    .toLowerCase()
+    .split(FRAME)
+    .map((part) => part.trim());
+  if (rest.length > 0) return false;
+  if (tail === undefined) return lead !== "" && lower.includes(lead);
+  return (
+    lead !== "" &&
+    tail !== "" &&
+    indexesOf(lower, lead).some((at) => isWordAt(lower, lead, at) && lower.slice(at + lead.length, at + lead.length + FRAME_REACH).includes(tail))
+  );
+};
+
+const statesConcrete = (text: Text, concrete: readonly string[]): boolean => {
+  const lower = text.text.toLowerCase();
+  return concrete.some((entry) => concreteIn(lower, entry));
+};
+
+const grantsRight = (text: Text, permissions: readonly LexiconEntry[]): boolean => {
+  const lower = text.text.toLowerCase();
+  const ending = withoutEnding(lower);
+  return permissions
+    .filter((entry) => entry.pattern !== "")
+    .some((entry) => (entry.position === "after" ? ending.endsWith(entry.pattern.toLowerCase()) : wordIn(lower, entry.pattern)));
+};
+
+/** A hit inside a longer hit at the same place (速やかに in 可及的速やかに) is that longer word. */
+const isInsideLonger = (hit: Hit, hits: readonly Hit[]): boolean =>
+  hits.some((other) => other.word.length > hit.word.length && other.at <= hit.at && hit.at + hit.word.length <= other.at + other.word.length);
+
+/** The vague limits in one sentence, in order. Matching ignores case. */
+const vagueIn = (text: Text, vague: readonly string[]): VagueDeadline[] => {
+  const lower = text.text.toLowerCase();
+  const hits = vague
+    .filter((word) => word !== "")
+    .flatMap((word) =>
+      indexesOf(lower, word.toLowerCase())
+        .filter((at) => isWordAt(lower, word, at))
+        .map((at) => ({ at, word })),
+    );
+  return hits
+    .filter((hit) => !isInsideLonger(hit, hits))
+    .toSorted((left, right) => left.at - right.at)
+    .map((hit) => ({ offset: text.start + hit.at, word: text.text.slice(hit.at, hit.at + hit.word.length) }));
+};
+
+/**
+ * Each vague limit in a sentence that states no concrete one and grants no right, when more sentences of the document
+ * state a concrete one than hold such a vague one: the vague limits are then the document's minority.
+ */
+export const vagueDeadlines = (texts: readonly Text[], words: DeadlineWords): VagueDeadline[] => {
+  const perSentence = texts.map((text) => (statesConcrete(text, words.concrete) || grantsRight(text, words.permissions) ? [] : vagueIn(text, words.vague)));
+  const vagueSentences = perSentence.filter((hits) => hits.length > 0).length;
+  const concreteSentences = texts.filter((text) => statesConcrete(text, words.concrete)).length;
+  return concreteSentences > vagueSentences ? perSentence.flat() : [];
+};
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+export const vagueDeadline: Detector = (doc): Finding[] =>
+  vagueDeadlines(
+    doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text })),
+    {
+      vague: patternsOf(doc, "vague-deadline"),
+      concrete: patternsOf(doc, "concrete-deadline"),
+      permissions: doc.lexicons["deadline-permission"] ?? [],
+    },
+  ).map((hit) => ({
+    rule: "vague-deadline",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, hit.offset),
+    values: { word: hit.word, offset: hit.offset },
+  }));

package/src/furigana.ts

@@ -0,0 +1,20 @@
+import type { Span } from "./plugin.ts";
+
+/** ひらがなと、読みの中に書く長音・中黒・空白だけの括弧書き。 */
+const KANA_ASIDE = /[（(][\p{Script=Hiragana}ー・ \u3000]+[）)]/gu;
+
+const HIRAGANA = /\p{Script=Hiragana}/u;
+/** 読みを付ける語の終わりの字。ひらがなの後ろの括弧書きは読みではなく挟んだ言葉（「これは（たぶん）」）。 */
+const WORD_END = /[\p{L}\p{N}]/u;
+
+/**
+ * text の中の、語の直後のふりがなの括弧（「HTTP（えいちてぃーてぃーぴー）」「脆弱性（ぜいじゃくせい）」）の範囲。括弧を含む。
+ * 語の読みであって、語の書き方ではない。位置は text の先頭を 0 とする。
+ */
+export const furiganaSpans = (text: string): Span[] =>
+  [...text.matchAll(KANA_ASIDE)]
+    .filter((match) => {
+      const before = text.charAt(match.index - 1);
+      return HIRAGANA.test(match[0]) && WORD_END.test(before) && !HIRAGANA.test(before);
+    })
+    .map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/genre-load.ts

@@ -1,13 +1,11 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { parse } from "yaml";
 import { parseGenres, presetLevelsOf, presetProfileOf, withRuleOffs, type GenreData, type PresetLevels } from "./genre-parse.ts";
 import { loadRuleOffs } from "./rule-offs.ts";
+import { PACKAGE_DIR, readText } from "./package-files.ts";
 
-const PACKAGE = join(dirname(fileURLToPath(import.meta.url)), "..");
-const GENRES_FILE = join(PACKAGE, "genres.yaml");
-const RULES_DIR = join(PACKAGE, "rules");
+const GENRES_FILE = join(PACKAGE_DIR, "genres.yaml");
+const RULES_DIR = join(PACKAGE_DIR, "rules");
 
 const loaded: { value: GenreData | undefined } = { value: undefined };
 
@@ -15,7 +13,7 @@ const loaded: { value: GenreData | undefined } = { value: undefined };
 export const loadGenres = (): GenreData => {
   if (loaded.value !== undefined) return loaded.value;
   try {
-    loaded.value = withRuleOffs(parseGenres(parse(readFileSync(GENRES_FILE, "utf8"))), loadRuleOffs(RULES_DIR));
+    loaded.value = withRuleOffs(parseGenres(parse(readText(GENRES_FILE))), loadRuleOffs(RULES_DIR));
   } catch (error) {
     throw new Error(`cannot read ${GENRES_FILE}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }

package/src/grade/ai-score.ts

@@ -0,0 +1,32 @@
+import { shownSignsOf, type AiLevel, type AiScore, type NotScored } from "../ai-score/score.ts";
+
+// The AI-likeness quick score as one output's result carries it, and its levels counted over many outputs. Pure.
+
+/** One output's quick score: its level (null when not scored, and why), the signs, and which showed. */
+export type GradeAiScore = {
+  readonly level: AiLevel | null;
+  readonly notScored: NotScored["reason"] | null;
+  readonly signs: number;
+  readonly compared: number;
+  /** The signs that counted: rule ids, and structure measures as structure:<id>. */
+  readonly shown: readonly string[];
+};
+
+/** How many outputs reached each level, and how many were not scored. */
+export type AiLevelCounts = Readonly<Record<AiLevel | "notScored", number>>;
+
+export const gradeAiScoreOf = (score: AiScore): GradeAiScore => ({
+  level: score.level ?? null,
+  notScored: score.notScored?.reason ?? null,
+  signs: score.signs,
+  compared: score.compared,
+  shown: shownSignsOf(score),
+});
+
+/** The levels of the outputs that carry a score, or undefined when none does (results written before the score existed). */
+export const aiLevelCountsOf = (scores: readonly (GradeAiScore | undefined)[]): AiLevelCounts | undefined => {
+  const scored = scores.filter((score) => score !== undefined);
+  if (scored.length === 0) return undefined;
+  const count = (level: AiLevel): number => scored.filter((score) => score.level === level).length;
+  return { low: count("low"), medium: count("medium"), high: count("high"), notScored: scored.filter((score) => score.level === null).length };
+};

package/src/grade/finding.ts

@@ -0,0 +1,16 @@
+import type { SourceCheck } from "../check-source.ts";
+import type { Finding } from "../plugin.ts";
+import { messageOf } from "../render/text.ts";
+import type { GradeFinding } from "./result.ts";
+
+/** One finding as `chaff grade` writes it: the rule, the level, where, and the message the command line prints. */
+export const findingOf = (finding: Finding, check: SourceCheck): GradeFinding => {
+  const rule = check.rules.find((entry) => entry.id === finding.rule);
+  return {
+    rule: finding.rule,
+    level: finding.severity,
+    line: finding.line,
+    column: finding.column,
+    message: rule === undefined ? finding.rule : messageOf(rule, finding, check.language),
+  };
+};

package/src/grade/grade-item.ts

@@ -1,9 +1,8 @@
 import { checkSource, type SourceCheck } from "../check-source.ts";
 import type { Allowed } from "../compare/outcome.ts";
 import { missingSections } from "../detectors/team.ts";
-import { messageOf } from "../render/text.ts";
 import { uiLanguageOf, type UiLanguage } from "../ui.ts";
-import type { Finding } from "../plugin.ts";
+import { findingOf } from "./finding.ts";
 import { citationsAgainst, factsAgainst, OUTPUT_PATH, type CitationsRead, type ItemReading } from "./checks.ts";
 import { contextsAgainst, type ContextsRead } from "./contexts.ts";
 import type { GradeItem } from "./item.ts";
@@ -13,22 +12,13 @@ import type { Rubric } from "./rubric.ts";
 import { rubricVerdict } from "./rubric-verdict.ts";
 import type { GradeSettings } from "./stamp.ts";
 import { GRADE_TEXT } from "./text.ts";
+import { aiScoreOfDocument } from "../ai-score/of-document.ts";
+import { gradeAiScoreOf } from "./ai-score.ts";
 import { defaultVerdict, type Verdict } from "./verdict.ts";
 
 /** One run's settings, its `grade:` rubric when chaff.yaml has one, and its stamp, which every result carries. */
 export type GradeSetup = GradeSettings & { readonly stamp: Stamp; readonly rubric?: Rubric | undefined };
 
-const findingOf = (finding: Finding, check: SourceCheck): GradeFinding => {
-  const rule = check.rules.find((entry) => entry.id === finding.rule);
-  return {
-    rule: finding.rule,
-    level: finding.severity,
-    line: finding.line,
-    column: finding.column,
-    message: rule === undefined ? finding.rule : messageOf(rule, finding, check.language),
-  };
-};
-
 /** The fact kinds the rubric lets change (`allow_dropped`, `allow_added`), as compare's --allow-dropped and --allow-added. */
 const allowedBy = (rubric: Rubric | undefined): Allowed => ({
   dropped: new Set(rubric?.facts?.allowDropped ?? []),
@@ -126,6 +116,7 @@ export const gradeItem = async (item: GradeItem, setup: GradeSetup): Promise<Gra
     citations: citationsOf(checked),
     ...(checked.contexts === undefined ? {} : { contexts: checked.contexts.contexts }),
     ...(score === undefined ? {} : { score }),
+    aiScore: gradeAiScoreOf(aiScoreOfDocument(checked.check.doc, checked.check.rules, checked.check.genre.genre)),
     pass: verdict.pass,
     failedBecause: verdict.failedBecause,
     stamp: setup.stamp,