chaffjs 0.19.0 → 0.21.0

package/src/derived/elapsed.ts

@@ -0,0 +1,125 @@
+import type { Span } from "../plugin.ts";
+import { bySentence } from "./sentence-buckets.ts";
+
+/**
+ * 起点の年から数えた年数（「2015年創業」と「創業10年」、「1980年生まれ」と「45歳」）を、文書の日付の年と比べる。
+ * 年数は、文書の年から起点の年を引いた数と、前後一年まで合えばよい（誕生日の前後、「10年目」の数え方）。それより離れていれば言う。
+ * 創業の年数は、起点の語のすぐ後ろか前に、つなぎの語（から、以来、since）だけを挟んで書いたもの（「創業10年」「設立から10年」）。
+ * 起点の年は同じ文の中で起点の語に一番近い年、無ければ文書の中で起点の語に付いた年（一通りのときだけ）。
+ * 年齢は、生まれた年と同じ文の年齢だけを比べる（文に生まれた年と年齢が一つずつのとき）。別の人の年齢と組にしないため。
+ */
+export type Year = Span & { readonly year: number };
+
+export type Elapsed = Span & { readonly amount: number };
+
+export type OriginWord = Span & { readonly pattern: string };
+
+export type ElapsedInput = {
+  readonly source: string;
+  readonly sentences: readonly Span[];
+  readonly years: readonly Year[];
+  /** 創業・設立・founded など、年数を数え始める語。 */
+  readonly foundings: readonly OriginWord[];
+  /** 生まれ・born など。 */
+  readonly births: readonly OriginWord[];
+  /** 年数（10年、20周年、10 years）。 */
+  readonly elapsed: readonly Elapsed[];
+  /** 年齢（45歳、aged 45）。 */
+  readonly ages: readonly Elapsed[];
+  /** 起点の語と年数のあいだに書いてよい語（から、以来、since）。何も挟まないのもよい。 */
+  readonly links: readonly string[];
+  /** 文書の日付の年。 */
+  readonly reference: number;
+};
+
+export type ElapsedMismatch = { readonly elapsed: Elapsed; readonly origin: Year; readonly expected: number };
+
+const TOLERANCE = 1;
+
+const distance = (left: Span, right: Span): number => Math.max(0, left.start - right.end, right.start - left.end);
+
+const nearest = <T extends Span>(spans: readonly T[], to: Span): T | undefined =>
+  spans.reduce<T | undefined>((best, span) => (best === undefined || distance(span, to) < distance(best, to) ? span : best), undefined);
+
+/** 起点の語と年数のあいだが、空か、つなぎの語だけ。 */
+const attached = (input: ElapsedInput, word: Span, amount: Span): boolean => {
+  const between = (word.end <= amount.start ? input.source.slice(word.end, amount.start) : input.source.slice(amount.end, word.start)).trim().toLowerCase();
+  return between === "" || input.links.some((link) => link.toLowerCase() === between);
+};
+
+const mismatchOf = (input: ElapsedInput, elapsed: Elapsed, origin: Year): ElapsedMismatch[] => {
+  const expected = input.reference - origin.year;
+  return expected >= 0 && Math.abs(elapsed.amount - expected) > TOLERANCE ? [{ elapsed, origin, expected }] : [];
+};
+
+/** 起点の年は、起点の語のすぐ近く（「2015年に創業」「founded in 2015」）に書いたものだけ。同じ文の遠い数（Model 2015）は年と読まない。 */
+const MAX_YEAR_DISTANCE = 6;
+
+/** 一つの文の中の、読んだものすべて。 */
+type InSentence = {
+  readonly years: readonly Year[];
+  readonly foundings: readonly OriginWord[];
+  readonly births: readonly OriginWord[];
+  readonly elapsed: readonly Elapsed[];
+  readonly ages: readonly Elapsed[];
+};
+
+const yearAt = (years: readonly Year[], word: Span): Year | undefined => {
+  const year = nearest(years, word);
+  return year !== undefined && distance(year, word) <= MAX_YEAR_DISTANCE ? year : undefined;
+};
+
+/** 文書の中で、起点の語（創業、設立、founded）に付いた年。一通りに決まらなければ undefined。 */
+const documentYear = (sentences: readonly InSentence[]): Year | undefined => {
+  const found = sentences.flatMap((sentence) =>
+    sentence.foundings.flatMap((word) => {
+      const year = yearAt(sentence.years, word);
+      return year === undefined ? [] : [year];
+    }),
+  );
+  return new Set(found.map((year) => year.year)).size === 1 ? found[0] : undefined;
+};
+
+const foundingMismatches = (input: ElapsedInput, sentence: InSentence, fallback: Year | undefined): ElapsedMismatch[] =>
+  sentence.elapsed.flatMap((elapsed) => {
+    const word = sentence.foundings.find((candidate) => attached(input, candidate, elapsed));
+    if (word === undefined) return [];
+    const origin = yearAt(sentence.years, word) ?? fallback;
+    return origin === undefined ? [] : mismatchOf(input, elapsed, origin);
+  });
+
+const ageMismatches = (input: ElapsedInput, sentence: InSentence): ElapsedMismatch[] => {
+  const [word] = sentence.births;
+  const [age] = sentence.ages;
+  if (sentence.births.length !== 1 || sentence.ages.length !== 1 || word === undefined || age === undefined) return [];
+  const origin = sentence.years.length === 1 ? sentence.years[0] : undefined;
+  return origin === undefined ? [] : mismatchOf(input, age, origin);
+};
+
+/** 文書の年より前の年だけを起点にする。文書の日付そのもの（「2026年4月1日現在、創業10年」）は起点ではない。 */
+const sentencesOf = (input: ElapsedInput): InSentence[] => {
+  const groups = {
+    years: bySentence(
+      input.sentences,
+      input.years.filter((year) => year.year < input.reference),
+    ),
+    foundings: bySentence(input.sentences, input.foundings),
+    births: bySentence(input.sentences, input.births),
+    elapsed: bySentence(input.sentences, input.elapsed),
+    ages: bySentence(input.sentences, input.ages),
+  };
+  const indexes = [...new Set([...groups.foundings.keys(), ...groups.births.keys()])].toSorted((left, right) => left - right);
+  return indexes.map((index) => ({
+    years: groups.years.get(index) ?? [],
+    foundings: groups.foundings.get(index) ?? [],
+    births: groups.births.get(index) ?? [],
+    elapsed: groups.elapsed.get(index) ?? [],
+    ages: groups.ages.get(index) ?? [],
+  }));
+};
+
+export const elapsedMismatches = (input: ElapsedInput): ElapsedMismatch[] => {
+  const sentences = sentencesOf(input);
+  const fallback = documentYear(sentences);
+  return sentences.flatMap((sentence) => [...foundingMismatches(input, sentence, fallback), ...ageMismatches(input, sentence)]);
+};

package/src/derived/relative-dates.ts

@@ -0,0 +1,96 @@
+import type { Span } from "../plugin.ts";
+import { calendarDateOf, dateOf, shifted, valueOf, type CalendarDate, type DurationUnit } from "./date-arithmetic.ts";
+
+/**
+ * 基準の日付からの相対で書いた日付（「10月2日に申し込み、3日後の10月5日に通知」"Applications open on May 1, 2026. Two weeks
+ * later, on May 15, 2026, …"）。相対の期間のすぐ後ろに書いた日付を、基準の日付に期間を足した（前なら引いた）日と比べる。
+ * 基準は、同じ文で相対の期間より前にある一番近い日付。文が相対の期間で始まる（「Two weeks later, …」）ときだけ、前の文の日付も
+ * 基準にする。基準と書いた日付の片方にしか年が無ければ、月日だけを比べる。
+ */
+export type DatedValue = Span & { readonly value: string };
+
+/** 「3日後」「two weeks later」: 期間と向き（後なら 1、前なら -1）。 */
+export type Relative = Span & { readonly amount: number; readonly unit: DurationUnit; readonly direction: 1 | -1 };
+
+export type RelativeMismatch = { readonly base: DatedValue; readonly relative: Relative; readonly target: DatedValue; readonly expected: string };
+
+export type RelativeInput = {
+  readonly source: string;
+  /** 文の始まりの昇順。 */
+  readonly sentences: readonly Span[];
+  /** 書いた順の日付。 */
+  readonly dates: readonly DatedValue[];
+  readonly relatives: readonly Relative[];
+  /** 相対の語と日付のあいだに書いてよい語（の、on）。空白と区切りの記号（、, (）は、いつでもよい。 */
+  readonly links: readonly string[];
+};
+
+const SEPARATORS = /[\s,、，(（:：]/gu;
+
+/** start の昇順の列で、start が offset 以上の最初の位置。二分探索で、相対の期間ごとに文書の頭から数え直さない。 */
+const firstAtOrAfter = (spans: readonly Span[], offset: number): number => {
+  let low = 0;
+  let high = spans.length;
+  while (low < high) {
+    const middle = (low + high) >> 1;
+    if ((spans[middle]?.start ?? Infinity) < offset) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+};
+
+const sentenceIndexOf = (sentences: readonly Span[], offset: number): number => {
+  const index = firstAtOrAfter(sentences, offset + 1) - 1;
+  const sentence = sentences[index];
+  return sentence !== undefined && offset < sentence.end ? index : -1;
+};
+
+/** 文の頭から相対の期間までに、空白と記号のほかに何も無い。 */
+const opensSentence = (source: string, sentence: Span, relative: Relative): boolean => !/[\p{L}\p{N}]/u.test(source.slice(sentence.start, relative.start));
+
+/** 相対の語のすぐ後ろの日付。あいだは区切りの記号と、つなぎの語だけ。 */
+const targetOf = (input: RelativeInput, relative: Relative): DatedValue | undefined => {
+  const next = input.dates[firstAtOrAfter(input.dates, relative.end)];
+  if (next === undefined) return undefined;
+  const between = input.source.slice(relative.end, next.start).replace(SEPARATORS, "").toLowerCase();
+  return between === "" || input.links.some((link) => link.replace(SEPARATORS, "").toLowerCase() === between) ? next : undefined;
+};
+
+/** 同じ文で、相対の期間より前にある一番近い日付。文の頭の相対の期間なら、前の文まで見る。 */
+const baseOf = (input: RelativeInput, relative: Relative): DatedValue | undefined => {
+  const index = sentenceIndexOf(input.sentences, relative.start);
+  const sentence = input.sentences[index];
+  if (sentence === undefined) return undefined;
+  const from = opensSentence(input.source, sentence, relative) ? (input.sentences[index - 1]?.start ?? sentence.start) : sentence.start;
+  const before = input.dates[firstAtOrAfter(input.dates, relative.start) - 1];
+  return before !== undefined && before.end <= relative.start && before.start >= from ? before : undefined;
+};
+
+/** 年の無い月日は、年を決めずに数えられない（2月28日の1日後は、うるう年なら2月29日）。考えられる年をすべて試す。 */
+const LEAP_YEAR = 2000;
+const COMMON_YEAR = 2001;
+
+const baseYears = (base: CalendarDate, target: CalendarDate): number[] => {
+  if (base.year !== undefined) return [base.year];
+  return target.year === undefined ? [LEAP_YEAR, COMMON_YEAR] : [target.year - 1, target.year, target.year + 1];
+};
+
+const mismatchOf = (base: DatedValue, relative: Relative, target: DatedValue): RelativeMismatch | undefined => {
+  const [baseDate, targetDate] = [calendarDateOf(base.value), calendarDateOf(target.value)];
+  if (baseDate === undefined || targetDate === undefined) return undefined;
+  const withYear = baseDate.year !== undefined && targetDate.year !== undefined;
+  const written = withYear ? target.value : valueOf(dateOf(targetDate), false);
+  const expected = baseYears(baseDate, targetDate).map((year) =>
+    valueOf(shifted(dateOf({ ...baseDate, year }), relative.amount * relative.direction, relative.unit), withYear),
+  );
+  const [shown] = expected;
+  return shown === undefined || expected.includes(written) ? undefined : { base, relative, target, expected: shown };
+};
+
+export const relativeMismatches = (input: RelativeInput): RelativeMismatch[] =>
+  input.relatives.flatMap((relative) => {
+    const target = targetOf(input, relative);
+    const base = baseOf(input, relative);
+    const mismatch = target === undefined || base === undefined ? undefined : mismatchOf(base, relative, target);
+    return mismatch === undefined ? [] : [mismatch];
+  });

package/src/derived/sentence-buckets.ts

@@ -0,0 +1,29 @@
+import type { Span } from "../plugin.ts";
+
+/** 文の始まりの昇順の列で、span をすっかり含む文の番号。無ければ -1。二分探索で引く。 */
+const sentenceIndexOf = (sentences: readonly Span[], span: Span): number => {
+  let low = 0;
+  let high = sentences.length - 1;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    const sentence = sentences[middle];
+    if (sentence === undefined) return -1;
+    if (span.start < sentence.start) high = middle - 1;
+    else if (span.start >= sentence.end) low = middle + 1;
+    else return span.end <= sentence.end ? middle : -1;
+  }
+  return -1;
+};
+
+/** span を文ごとに分ける。文をまたぐ span はどの文にも入れない。文の数 × span の数を回らないため。 */
+export const bySentence = <T extends Span>(sentences: readonly Span[], spans: readonly T[]): ReadonlyMap<number, readonly T[]> => {
+  const buckets = new Map<number, T[]>();
+  spans.forEach((span) => {
+    const index = sentenceIndexOf(sentences, span);
+    if (index === -1) return;
+    const bucket = buckets.get(index);
+    if (bucket === undefined) buckets.set(index, [span]);
+    else bucket.push(span);
+  });
+  return buckets;
+};

package/src/detectors/absolute-exception.ts

@@ -0,0 +1,102 @@
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Span, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { contentKey, type Obligation } from "../structure/modal-conflict.ts";
+import { actOf, contradictedAbsolutes, type Statement } from "../structure/absolute-exception.ts";
+import { linesOf, lineNumberAt } from "../structure/lines.ts";
+import { isWithinAny, QUOTATION_MARKS, quotedIn } from "../quoted-span.ts";
+import { entryRanges } from "./lexicon-match.ts";
+import { obligationsOf } from "./modal-conflict.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const REQUIRING: ReadonlySet<string> = new Set(["must", "must-not"]);
+
+type Hit = { readonly word: string; readonly span: Span };
+
+/** Where the lexicon's words stand in the sentence, outside quotations, in reading order. Needs the sentence's tokens. */
+const hitsIn = (sentence: Sentence, lexicon: Lexicon, quoted: readonly Span[]): Hit[] => {
+  const tokens = sentence.tokens ?? [];
+  return lexicon
+    .flatMap((entry) =>
+      entryRanges(sentence, entry).flatMap((range) => {
+        const first = tokens[range.start];
+        const last = tokens[range.end - 1];
+        if (first === undefined || last === undefined) return [];
+        const span = { start: first.span.start, end: last.span.end };
+        return isWithinAny(quoted, span) ? [] : [{ word: entry.pattern, span }];
+      }),
+    )
+    .toSorted((left, right) => left.span.start - right.span.start);
+};
+
+const within = (span: Span, offset: number): boolean => offset >= span.start && offset < span.end;
+
+/** The units an exception may sit in and still be the statement's own proviso: articles, then lists, then paragraphs. */
+type Units = { readonly articles: readonly Span[]; readonly lists: readonly Span[]; readonly paragraphs: readonly Span[] };
+
+const unitsOf = (doc: ProseDocument, tree: StructureNode): Units => ({
+  articles: inDocumentOrder(tree).flatMap((node) => (node.kind === "article" ? [node.span] : [])),
+  lists: doc.lists.map((list) => list.span),
+  paragraphs: doc.paragraphs.map((paragraph) => paragraph.span),
+});
+
+/** The innermost span holding the offset: an article nested in another is a unit of its own. */
+const innermost = (spans: readonly Span[], offset: number): Span | undefined =>
+  spans
+    .filter((span) => within(span, offset))
+    .reduce<Span | undefined>((inner, span) => (inner === undefined || span.start > inner.start ? span : inner), undefined);
+
+const unitAt = (units: Units, offset: number): number =>
+  [units.articles, units.lists, units.paragraphs].map((spans) => innermost(spans, offset)).find((span) => span !== undefined)?.start ?? offset;
+
+type Words = { readonly absolute: Lexicon; readonly exception: Lexicon; readonly lightVerbs: ReadonlySet<string> };
+
+/** The sentence read for the rule, or nothing when it holds neither word. Only such sentences pay for the unit and the markers. */
+const statementOf = (sentence: Sentence, obligations: readonly Obligation[], words: Words, units: Units): Statement | undefined => {
+  const quoted = quotedIn(sentence, QUOTATION_MARKS);
+  const absolute = hitsIn(sentence, words.absolute, quoted);
+  const exception = hitsIn(sentence, words.exception, quoted);
+  const tokens = sentence.tokens;
+  if ((absolute.length === 0 && exception.length === 0) || tokens === undefined) return undefined;
+  const markers = obligations.filter((obligation) => within(sentence.span, obligation.start));
+  const read = [...absolute, ...exception].map((hit) => hit.span);
+  const key = contentKey(tokens, [...markers, ...read]);
+  const [marker] = markers;
+  return {
+    offset: sentence.span.start,
+    words: key === "" ? [] : key.split(" "),
+    absolute: absolute[0]?.word,
+    exception: exception[0]?.word,
+    obligation: markers.length === 1 && REQUIRING.has(marker?.type ?? ""),
+    act: marker === undefined ? undefined : actOf(tokens, marker, read, words.lightVerbs),
+    unit: unitAt(units, sentence.span.start),
+  };
+};
+
+/** An absolute obligation (すべての〜は…しなければならない, "must always") that a later sentence elsewhere makes an exception to. */
+export const absoluteException: Detector = (doc, options): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const words = {
+    absolute: options.lexicon ?? [],
+    exception: doc.lexicons["exception-marker"] ?? [],
+    lightVerbs: new Set((doc.lexicons["light-verb"] ?? []).map((entry) => entry.pattern.toLowerCase())),
+  };
+  const obligations = obligationsOf(doc.structure);
+  const units = unitsOf(doc, doc.structure);
+  const statements = doc.sentences
+    .filter((sentence) => sentence.embeddedLanguage === undefined)
+    .flatMap((sentence) => statementOf(sentence, obligations, words, units) ?? []);
+  const lines = linesOf(doc.source);
+  return contradictedAbsolutes(statements).map(({ absolute, exception }) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, absolute.offset),
+    values: {
+      word: absolute.absolute ?? "",
+      exception: exception.exception ?? "",
+      otherLine: lineNumberAt(lines, exception.offset) ?? 0,
+      offset: absolute.offset,
+    },
+  }));
+};

package/src/detectors/abstract-length.ts

@@ -0,0 +1,126 @@
+// An abstract longer than the limit, or a paper with sections and no abstract. Pure. What labels an abstract (要旨,
+// Abstract) and what names a paper's section (はじめに, Methods) come from the language's abstract-heading and
+// paper-section-heading lexicons. An abstract in the other language (the English Abstract of a Japanese paper) is
+// measured in that language's unit and against its limit.
+import { lengthOf } from "../measure.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, DetectorOptions, Finding, LengthUnit, ProseDocument, Sentence, Span } from "../plugin.ts";
+
+/** A paper with this many section headings (Introduction, Methods, …) is expected to have an abstract. */
+const MIN_SECTIONS = 2;
+
+/** The marks around a label: a heading's number, 【】, a colon or a full stop after it, emphasis. */
+const LABEL_MARKS = new Set(" \t\n\u3000.．#*_【[（():：】])）0123456789");
+/** Where a label at a paragraph's head ends: "Abstract: We …", "【要旨】本研究は…", "Abstract.We …". */
+const LABEL_ENDS = ["】", ":", "：", ".", "．"];
+/** A label at a paragraph's head is a word or two: past this many characters the colon belongs to a sentence. */
+const MAX_LABEL = 24;
+
+export const labelOf = (text: string): string => {
+  const chars = [...text];
+  const first = chars.findIndex((char) => !LABEL_MARKS.has(char));
+  const last = chars.findLastIndex((char) => !LABEL_MARKS.has(char));
+  return first === -1
+    ? ""
+    : chars
+        .slice(first, last + 1)
+        .join("")
+        .toLowerCase();
+};
+
+/** The label at a paragraph's head and how long it is with the spaces after it, or undefined. */
+export const headLabel = (text: string): { readonly label: string; readonly length: number } | undefined => {
+  const head = text.slice(0, MAX_LABEL);
+  const end = LABEL_ENDS.map((mark) => head.indexOf(mark))
+    .filter((index) => index > 0)
+    .toSorted((left, right) => left - right)[0];
+  if (end === undefined) return undefined;
+  const rest = text.slice(end + 1);
+  return { label: labelOf(head.slice(0, end + 1)), length: end + 1 + rest.length - rest.trimStart().length };
+};
+
+export type AbstractSpan = { readonly label: number; readonly body: Span };
+
+type Words = { readonly abstracts: ReadonlySet<string>; readonly sections: ReadonlySet<string> };
+
+const wordsOf = (doc: ProseDocument): Words => {
+  const set = (id: string): ReadonlySet<string> => new Set((doc.lexicons[id] ?? []).map((entry) => entry.pattern.toLowerCase()));
+  return { abstracts: set("abstract-heading"), sections: set("paper-section-heading") };
+};
+
+/** Abstracts under a heading of their own: the text up to the next heading. */
+const underHeadings = (doc: ProseDocument, words: Words): AbstractSpan[] => {
+  const headings = doc.markup?.headings ?? [];
+  return headings.flatMap((heading, index): AbstractSpan[] =>
+    words.abstracts.has(labelOf(heading.text))
+      ? [{ label: heading.start, body: { start: heading.end, end: headings[index + 1]?.start ?? doc.source.length } }]
+      : [],
+  );
+};
+
+/** Abstracts labelled in a paragraph: the label alone on its line (the next paragraph is the abstract) or at its head. */
+const inParagraphs = (doc: ProseDocument, words: Words): AbstractSpan[] =>
+  doc.paragraphs.flatMap((paragraph, index): AbstractSpan[] => {
+    const text = doc.source.slice(paragraph.span.start, paragraph.span.end);
+    const next = doc.paragraphs[index + 1];
+    if (words.abstracts.has(labelOf(text))) return next === undefined ? [] : [{ label: paragraph.span.start, body: next.span }];
+    const head = headLabel(text);
+    if (head === undefined || !words.abstracts.has(head.label)) return [];
+    return [{ label: paragraph.span.start, body: { start: paragraph.span.start + head.length, end: paragraph.span.end } }];
+  });
+
+export const abstractsOf = (doc: ProseDocument): AbstractSpan[] => {
+  const words = wordsOf(doc);
+  const found = [...underHeadings(doc, words), ...inParagraphs(doc, words)].toSorted((left, right) => left.label - right.label);
+  return found.filter((abstract, index) => found.findIndex((other) => other.label === abstract.label) === index);
+};
+
+/** The first heading that names a paper's section, when there are MIN_SECTIONS of them; undefined otherwise. */
+export const firstSectionHeading = (doc: ProseDocument): number | undefined => {
+  const words = wordsOf(doc);
+  const sections = (doc.markup?.headings ?? []).filter((heading) => words.sections.has(labelOf(heading.text)));
+  return sections.length >= MIN_SECTIONS ? sections[0]?.start : undefined;
+};
+
+type Measure = { readonly size: number; readonly limit: number | undefined; readonly unit: LengthUnit };
+
+/** The part of a sentence inside the span: a label at the head of the abstract's paragraph is not counted. */
+const clipped = (sentence: Sentence, body: Span): Sentence => {
+  const from = Math.max(0, body.start - sentence.span.start);
+  return from === 0 ? sentence : { ...sentence, text: sentence.text.slice(from), span: { start: sentence.span.start + from, end: sentence.span.end } };
+};
+
+/** The abstract's length, in the unit of the language most of its sentences are in, and that language's limit. */
+export const measureAbstract = (doc: ProseDocument, body: Span, options: DetectorOptions): Measure => {
+  const sentences = doc.sentences
+    .filter((sentence) => sentence.span.end > body.start && sentence.span.start < body.end)
+    .map((sentence) => clipped(sentence, body));
+  const embedded = sentences.filter((sentence) => sentence.embeddedLanguage !== undefined);
+  const other = embedded.length * 2 > sentences.length ? embedded[0]?.embeddedLanguage : undefined;
+  const unit = other?.lengthUnit ?? doc.lengthUnit;
+  const limit = other === undefined ? options.limit : options.embeddedLimits?.[other.id];
+  return { size: sentences.reduce((sum, sentence) => sum + lengthOf(sentence, unit), 0), limit, unit };
+};
+
+const finding = (doc: ProseDocument, offset: number, variant: string, values: Readonly<Record<string, number>>): Finding => ({
+  rule: "abstract-length",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, offset),
+  values: { ...values, offset },
+  variant,
+});
+
+export const abstractLength: Detector = (doc, options): Finding[] => {
+  const abstracts = abstractsOf(doc);
+  if (abstracts.length === 0) {
+    const section = firstSectionHeading(doc);
+    return section === undefined ? [] : [finding(doc, section, "missing", {})];
+  }
+  return abstracts.flatMap((found) => {
+    const measure = measureAbstract(doc, found.body, options);
+    if (measure.limit === undefined || measure.size <= measure.limit) return [];
+    return [finding(doc, found.label, measure.unit === "word" ? "words" : "chars", { count: measure.size, limit: measure.limit })];
+  });
+};

package/src/detectors/ai-phrasing.ts

@@ -29,7 +29,7 @@ const findingOf = (hit: Hit, values: Readonly<Record<string, number>>): Finding
 });
 
 /** 1000 語（日本語は 1000 字）あたりの数が上限を超えたら、当たった文をすべて言う。短い文書は密度が暴れるので測らない。 */
-const densityFindings = (doc: ProseDocument, hits: readonly Hit[], limit: number): Finding[] => {
+export const densityFindings = (doc: ProseDocument, hits: readonly Hit[], limit: number): Finding[] => {
   const length = wordsOf(doc);
   if (hits.length < PILE || length < MIN_DOCUMENT_LENGTH[doc.lengthUnit]) return [];
   const density = Math.round((hits.length / length) * PER * TENTHS) / TENTHS;
@@ -126,16 +126,14 @@ export const assistantResidue: Detector = (doc, options): Finding[] => {
   return tally.hits.map((hit) => findingOf(hit, { count: tally.counted.size, density: score, limit: options.limit }));
 };
 
-/** 埋め忘れた雛形の空欄（[Your Name]、【会社名】）。limit は指摘に要る数。 */
-export const unfilledPlaceholder: Detector = (doc, options): Finding[] => {
-  const words = options.lexicon ?? [];
-  const blanks = doc.sentences.flatMap((sentence) =>
-    placeholderSpans(sentence.text, words).map((span) => ({
-      sentence,
-      matched: sentence.text.slice(span.start, span.end),
-      offset: sentence.span.start + span.start,
-    })),
-  );
-  if (blanks.length === 0 || blanks.length < options.limit) return [];
-  return blanks.map((blank) => findingOf(blank, { count: blanks.length, limit: options.limit }));
-};
+/** 埋め忘れた雛形の空欄（[Your Name]、【会社名】、TBD: …）。1 つでも埋め忘れなので、段は数ではなく指摘の重さを決める。 */
+export const unfilledPlaceholder: Detector = (doc, options): Finding[] =>
+  doc.sentences
+    .flatMap((sentence) =>
+      placeholderSpans(sentence.text, options.lexicon ?? []).map((span) => ({
+        sentence,
+        matched: sentence.text.slice(span.start, span.end),
+        offset: sentence.span.start + span.start,
+      })),
+    )
+    .map((blank) => findingOf(blank, {}));

package/src/detectors/ai-structure.ts

@@ -0,0 +1,26 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { uiLanguageOf } from "../ui.ts";
+import { STRUCTURE_TEXT } from "../outline/structure-text.ts";
+import { structureOf } from "../structure-shape/of-document.ts";
+
+/**
+ * The document's outline is past the human articles on several structure measures at once (chaff outline's structure
+ * block): many headings, three-way splits, bold labels, uniform sections. One alone is ordinary; the limit is how many.
+ */
+export const aiStructure: Detector = (doc, options): Finding[] => {
+  const scored = structureOf(doc);
+  if (scored.score < options.limit) return [];
+  const text = STRUCTURE_TEXT[uiLanguageOf(doc.language)];
+  const names = scored.placements.filter((placement) => placement.beyond).map((placement) => text.features[placement.feature.id].name);
+  const heading = (doc.markup?.headings ?? []).find((entry) => entry.depth > 1) ?? doc.markup?.headings[0];
+  return [
+    {
+      rule: "ai-structure",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: heading?.text ?? "",
+      values: { word: names.join(text.listSeparator), count: scored.score, limit: options.limit, offset: heading?.start ?? 0 },
+    },
+  ];
+};