chaffjs 0.19.0 → 0.21.0

package/src/custom/dsl-fields.ts

@@ -0,0 +1,102 @@
+import type { LevelTable, Localized, Severity } from "../plugin.ts";
+import { RULE_GROUPS, ruleGuideOf, type RuleGroup, type RuleGuide } from "../rule-guide.ts";
+import { fieldProblems } from "../rule-fields.ts";
+import { failed, ok, type Checked } from "./checked.ts";
+
+// The fields a team's rule (custom_rules, or a plugin's rules) writes the way chaff's own rules/*.yaml do: levels,
+// use_for, group, summary, the example by language and rewrite. Each is optional; without it the rule reads as a team
+// rule always has. The shared fields are checked by rule-fields.ts, the one place chaff's own rules are checked too. Pure.
+
+const SEVERITIES: readonly Severity[] = ["info", "warning", "error"];
+const LEVEL_NAMES = ["strict", "normal", "relaxed"] as const;
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const printed = (value: unknown): string => (typeof value === "string" ? value : (JSON.stringify(value) ?? typeof value));
+
+const rankOf = (severity: Severity): number => SEVERITIES.indexOf(severity) + 1;
+
+/** level: one severity; normal is the rule's own, relaxed one lower, strict one higher, where there is one. */
+const tableFor = (severity: Severity): LevelTable => {
+  const rank = rankOf(severity);
+  return { ...(rank < SEVERITIES.length ? { strict: rank + 1 } : {}), normal: rank, ...(rank > 1 ? { relaxed: rank - 1 } : {}) };
+};
+
+const severityAt = (value: unknown): Severity | undefined => SEVERITIES.find((entry) => entry === value);
+
+/**
+ * levels: a severity for each of strict, normal and relaxed, as chaff's rules with nothing to count write them. A
+ * team's detector reports places, not counts, so a number has nothing to be compared with and is refused.
+ */
+const tableOf = (written: unknown): { table: LevelTable; severity: Severity } | undefined => {
+  if (!isRecord(written) || Object.keys(written).some((key) => !LEVEL_NAMES.some((name) => name === key))) return undefined;
+  const ranks = LEVEL_NAMES.flatMap((name) => {
+    const severity = severityAt(written[name]);
+    return severity === undefined ? [] : [[name, rankOf(severity)] as const];
+  });
+  const normal = severityAt(written["normal"]);
+  if (normal === undefined || ranks.length !== Object.keys(written).length) return undefined;
+  return { table: Object.fromEntries(ranks), severity: normal };
+};
+
+export type RuleLevels = { readonly table: LevelTable; readonly severity: Severity };
+
+/** level (one severity, as before) or levels (a severity per level). Not both: they would disagree on normal. */
+export const levelsOf = (raw: Readonly<Record<string, unknown>>, at: string): Checked<RuleLevels> => {
+  const [level, levels] = [raw["level"], raw["levels"]];
+  if (level !== undefined && levels !== undefined) return failed({ kind: "level-and-levels", at });
+  if (levels !== undefined) {
+    const read = tableOf(levels);
+    return read === undefined ? failed({ kind: "bad-levels", at, written: printed(levels) }) : ok(read);
+  }
+  if (level === undefined) return ok({ table: tableFor("warning"), severity: "warning" });
+  const severity = severityAt(level);
+  return severity === undefined ? failed({ kind: "bad-level", at, written: printed(level) }) : ok({ table: tableFor(severity), severity });
+};
+
+/** An example written by language ({ ja: { before, after } }) rather than as { before, after }. */
+const isExampleByLanguage = (example: unknown): example is Record<string, unknown> =>
+  isRecord(example) && Object.keys(example).length > 0 && !("before" in example) && !("after" in example);
+
+/** example's before and after, each by language, whichever form it is written in. */
+export const exampleSides = (example: unknown): { readonly before: unknown; readonly after: unknown } => {
+  if (!isRecord(example)) return { before: undefined, after: undefined };
+  if (!isExampleByLanguage(example)) return { before: example["before"], after: example["after"] };
+  const pairs = Object.entries(example).flatMap(([language, pair]) => (isRecord(pair) ? [[language, pair] as const] : []));
+  return {
+    before: Object.fromEntries(pairs.map(([language, pair]) => [language, pair["before"]])),
+    after: Object.fromEntries(pairs.map(([language, pair]) => [language, pair["after"]])),
+  };
+};
+
+export type Described = Pick<RuleGuide, "rewrite" | "rewriteDepth"> & {
+  readonly group: RuleGroup;
+  /** undefined: the rule's name stands for its summary. */
+  readonly summary: Localized | undefined;
+  /** undefined: every genre, as a team's rule always has. */
+  readonly useFor: readonly string[] | undefined;
+};
+
+const textOf = (value: unknown): Localized | undefined => {
+  if (typeof value === "string") return value.trim() === "" ? undefined : { ja: value.trim(), en: value.trim() };
+  return isRecord(value) ? ruleGuideOf({ summary: value }).summary : undefined;
+};
+
+/**
+ * The fields a team's rule shares with chaff's own, checked in rule-fields.ts. An example written as { before, after }
+ * is left to the caller, which has always read and reported it.
+ */
+export const describedOf = (raw: Readonly<Record<string, unknown>>, at: string, genres: readonly string[]): Checked<Described> => {
+  const shared = { ...raw, example: isExampleByLanguage(raw["example"]) ? raw["example"] : undefined };
+  const problems = fieldProblems(shared, genres).map((problem) => ({ kind: problem.kind, at, written: problem.written }));
+  if (problems.length > 0) return failed(...problems);
+  const { rewrite, rewriteDepth } = ruleGuideOf({ rewrite: raw["rewrite"] });
+  const useFor = raw["use_for"];
+  return ok({
+    group: RULE_GROUPS.find((group) => group === raw["group"]) ?? "team",
+    summary: textOf(raw["summary"]),
+    useFor: Array.isArray(useFor) ? useFor.map((entry) => String(entry)) : undefined,
+    rewrite,
+    rewriteDepth,
+  });
+};

package/src/custom/load.ts

@@ -2,6 +2,7 @@ import type { Config } from "../config/load.ts";
 import type { RuleDefinition } from "../plugin.ts";
 import { loadRules } from "../rule-load.ts";
 import { loadGenres } from "../genre-load.ts";
+import { knownGenres } from "../known-genres.ts";
 import { parseCustomRules, type CustomRules } from "./parse.ts";
 
 /** The team's custom_rules as rules, with what could not be read. A team's rule applies to every genre, like the team's words. */
@@ -9,6 +10,7 @@ export const customRulesOf = (config: Pick<Config, "customRules" | "baseDir">):
   parseCustomRules(config.customRules, {
     builtIn: new Set(loadRules("en").map((rule) => rule.id)),
     useFor: loadGenres().groups.map((group) => group.id),
+    genres: knownGenres(),
     baseDir: config.baseDir,
   });
 

package/src/custom/parse.ts

@@ -1,7 +1,10 @@
-import type { CustomSpec, LevelTable, Localized, RuleDefinition, Severity, TokenCondition } from "../plugin.ts";
+import type { CustomSpec, Localized, RuleDefinition, TokenCondition } from "../plugin.ts";
 import { regexRefusal, type RegexRefusal } from "./regex-safety.ts";
 import { posTags } from "./token-pattern.ts";
 import { modulePathOf, type ModulePathRefusal } from "./module-path.ts";
+import type { FieldProblem } from "../rule-fields.ts";
+import { failed, ok, type Checked } from "./checked.ts";
+import { describedOf, exampleSides, levelsOf, type Described, type RuleLevels } from "./dsl-fields.ts";
 
 // custom_rules in chaff.yaml: a team's own deterministic rules, written without code. Each becomes a RuleDefinition like the
 // built-in ones, so findings, explain, rules --json, stet, the baseline and SARIF treat it the same. Pure: the YAML comes in parsed.
@@ -26,18 +29,25 @@ export type CustomProblem =
   | { readonly kind: "bad-pattern"; readonly at: string; readonly refusal: RegexRefusal }
   | { readonly kind: "no-tokens"; readonly at: string }
   | { readonly kind: "bad-token"; readonly at: string; readonly index: number }
-  | { readonly kind: "unknown-pos"; readonly at: string; readonly written: string };
+  | { readonly kind: "unknown-pos"; readonly at: string; readonly written: string }
+  | { readonly kind: "level-and-levels"; readonly at: string }
+  | { readonly kind: "bad-levels"; readonly at: string; readonly written: string }
+  | (FieldProblem & { readonly at: string });
 
 export type CustomRules = { readonly rules: readonly RuleDefinition[]; readonly problems: readonly CustomProblem[] };
 
 /**
- * What parsing needs to know: the built-in rule ids (a team's rule may not take one), the genres a rule applies to, and
- * the folder a module's path is relative to (where chaff.yaml is).
+ * What parsing needs to know: the built-in rule ids (a team's rule may not take one), the genres a rule applies to when
+ * it does not say (useFor), every genre a use_for may name, and the folder a module's path is relative to (where chaff.yaml is).
  */
-export type CustomContext = { readonly builtIn: ReadonlySet<string>; readonly useFor: readonly string[]; readonly baseDir: string };
+export type CustomContext = {
+  readonly builtIn: ReadonlySet<string>;
+  readonly useFor: readonly string[];
+  readonly genres: readonly string[];
+  readonly baseDir: string;
+};
 
 const RULE_ID = /^[a-z][a-z0-9-]*$/u;
-const SEVERITIES: readonly Severity[] = ["info", "warning", "error"];
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 
@@ -58,12 +68,6 @@ const EVERY_LANGUAGE = "*";
 
 const exampleSideOf = (value: unknown): Localized | undefined => (nonEmpty(value) ? { [EVERY_LANGUAGE]: value.trim() } : byLanguageOf(value));
 
-/** One rule's own problems, with the rule's id (or its place in the list) as where. */
-type Checked<T> = { readonly value: T | undefined; readonly problems: readonly CustomProblem[] };
-
-const ok = <T>(value: T): Checked<T> => ({ value, problems: [] });
-const failed = <T>(...problems: CustomProblem[]): Checked<T> => ({ value: undefined, problems });
-
 type Pair = { readonly avoid: string; readonly use: string };
 
 /** words as a map (avoid: use) or a list (words to point at, with nothing to use instead). */
@@ -125,7 +129,8 @@ const moduleOf = (raw: Record<string, unknown>, at: string, baseDir: string): Ch
 };
 
 const specOf = (raw: Record<string, unknown>, type: string, at: string, baseDir: string): Checked<CustomSpec> => {
-  if (type === "words") return wordsOf(raw["words"], at);
+  // A words rule may take its words from a word list instead, one per language (a rule pack's lexicons/<language>/).
+  if (type === "words") return takesWordList(raw, type) ? ok({ type: "words", words: [] }) : wordsOf(raw["words"], at);
   if (type === "pattern") return patternOf(raw, at);
   if (type === "module") return moduleOf(raw, at, baseDir);
   return tokensOf(raw["tokens"], at);
@@ -137,28 +142,16 @@ const typeOf = (raw: Record<string, unknown>, at: string): Checked<string> => {
   return CUSTOM_TYPES.some((known) => known === type) ? ok(type) : failed({ kind: "unknown-type", at, written: type });
 };
 
-const severityOf = (raw: unknown, at: string): Checked<Severity> => {
-  if (raw === undefined) return ok("warning");
-  const severity = SEVERITIES.find((entry) => entry === raw);
-  return severity === undefined ? failed({ kind: "bad-level", at, written: typeof raw === "string" ? raw : printed(raw) }) : ok(severity);
-};
-
-/** The four words as severities: normal is the rule's own level, relaxed one lower, strict one higher, where there is one. */
-const levelsFor = (severity: Severity): LevelTable => {
-  const rank = SEVERITIES.indexOf(severity) + 1;
-  return { ...(rank < SEVERITIES.length ? { strict: rank + 1 } : {}), normal: rank, ...(rank > 1 ? { relaxed: rank - 1 } : {}) };
-};
-
 type Texts = { readonly name: Localized; readonly why: Localized; readonly how_to_fix: Localized; readonly before: Localized; readonly after: Localized };
 
 const textsOf = (raw: Record<string, unknown>, at: string): Checked<Texts> => {
-  const example = isRecord(raw["example"]) ? raw["example"] : {};
+  const example = exampleSides(raw["example"]);
   const found = {
     name: localizedOf(raw["name"]),
     why: localizedOf(raw["why"]),
     how_to_fix: localizedOf(raw["how_to_fix"]),
-    before: exampleSideOf(example["before"]),
-    after: exampleSideOf(example["after"]),
+    before: exampleSideOf(example.before),
+    after: exampleSideOf(example.after),
   };
   const missing = Object.entries(found).flatMap(([field, text]) =>
     text === undefined ? [{ kind: "missing" as const, at, field: field === "before" || field === "after" ? `example.${field}` : field }] : [],
@@ -179,9 +172,13 @@ const requiresOf = (raw: unknown, type: string, at: string): Checked<readonly st
   return unknown === undefined ? ok([...new Set(written)]) : failed({ kind: "bad-requires", at, written: unknown });
 };
 
-/** A module's word list by name; its detector gets it as options.lexicon. The other types carry their words themselves. */
-const wordListOf = (raw: unknown, type: string, at: string): Checked<string | undefined> => {
-  if (raw === undefined || type !== "module") return ok(undefined);
+/** A module reads a word list; so does a words rule that writes word_list in place of words. The others carry their words. */
+const takesWordList = (raw: Record<string, unknown>, type: string): boolean =>
+  raw["word_list"] !== undefined && (type === "module" || (type === "words" && raw["words"] === undefined));
+
+/** The word list by name; the detector gets it, in the document's language, as options.lexicon. */
+const wordListOf = (raw: unknown, takesList: boolean, at: string): Checked<string | undefined> => {
+  if (raw === undefined || !takesList) return ok(undefined);
   return nonEmpty(raw) ? ok(raw.trim()) : failed({ kind: "bad-word-list", at, written: printed(raw) });
 };
 
@@ -190,7 +187,7 @@ type Needs = { readonly requires: readonly string[]; readonly wordList: string |
 
 const needsOf = (raw: Record<string, unknown>, type: string, at: string): Checked<Needs> => {
   const requires = requiresOf(raw["requires"], type, at);
-  const wordList = wordListOf(raw["word_list"], type, at);
+  const wordList = wordListOf(raw["word_list"], takesWordList(raw, type), at);
   if (requires.value === undefined || wordList.problems.length > 0) return failed(...requires.problems, ...wordList.problems);
   return ok({ requires: requires.value, wordList: wordList.value });
 };
@@ -226,10 +223,11 @@ type Example = { readonly before: string; readonly after: string };
 type Parts = {
   readonly spec: CustomSpec;
   readonly needs: Needs;
-  readonly severity: Severity;
+  readonly levels: RuleLevels;
   readonly texts: Texts;
   readonly languages: readonly string[] | undefined;
   readonly examples: Readonly<Record<string, Example>>;
+  readonly described: Described;
 };
 
 const READER_LANGUAGES: readonly string[] = ["ja", "en"];
@@ -253,7 +251,7 @@ const definitionOf = (id: string, raw: Record<string, unknown>, parts: Parts, us
   message: localizedOf(raw["message"]) ?? defaultMessage(parts.spec, parts.texts.name),
   messages: {},
   placeholders: PLACEHOLDERS,
-  levels: levelsFor(parts.severity),
+  levels: parts.levels.table,
   level_sets: "severity",
   by_genre: {},
   how_to_find: HOW_TO_FIND[parts.spec.type],
@@ -266,18 +264,19 @@ const definitionOf = (id: string, raw: Record<string, unknown>, parts: Parts, us
   uses: [],
   from: [],
   languages: parts.languages,
-  use_for: useFor,
-  severity: parts.severity,
+  use_for: parts.described.useFor ?? useFor,
+  severity: parts.levels.severity,
   custom: parts.spec,
   // The reference and explain read a rule's plain-language fields from guide; a team's rule is listed with the team's words.
   guide: {
-    group: "team",
-    summary: parts.texts.name,
+    group: parts.described.group,
+    summary: parts.described.summary ?? parts.texts.name,
     examples: parts.examples,
     notFlagged: {},
     levelMeaning: {},
     sources: [],
-    rewrite: {},
+    rewrite: parts.described.rewrite,
+    rewriteDepth: parts.described.rewriteDepth,
   },
 });
 
@@ -289,24 +288,47 @@ const idOf = (raw: Record<string, unknown>, index: number, seen: ReadonlySet<str
   return seen.has(id) ? failed({ kind: "duplicate-id", at }) : ok(id);
 };
 
+/** Each field of one rule, checked. */
+type Checks = {
+  readonly id: Checked<string>;
+  readonly spec: Checked<CustomSpec>;
+  readonly needs: Checked<Needs>;
+  readonly levels: Checked<RuleLevels>;
+  readonly texts: Checked<Texts>;
+  readonly languages: Checked<readonly string[] | undefined>;
+  readonly described: Checked<Described>;
+};
+
+/** The rule's parts once every check passed; undefined when one has no value. */
+const partsOf = (checks: Checks, examples: Readonly<Record<string, Example>>): { readonly id: string; readonly parts: Parts } | undefined => {
+  const { id, spec, needs, levels, texts, described } = checks;
+  if (id.value === undefined || spec.value === undefined || needs.value === undefined) return undefined;
+  if (levels.value === undefined || texts.value === undefined || described.value === undefined) return undefined;
+  const parts = { spec: spec.value, needs: needs.value, levels: levels.value, texts: texts.value, languages: checks.languages.value, examples };
+  return { id: id.value, parts: { ...parts, described: described.value } };
+};
+
 const ruleOf = (raw: unknown, index: number, seen: ReadonlySet<string>, context: CustomContext): Checked<RuleDefinition> => {
   if (!isRecord(raw)) return failed({ kind: "not-a-map", at: `#${String(index + 1)}` });
   const id = idOf(raw, index, seen, context.builtIn);
   const at = id.value ?? (nonEmpty(raw["id"]) ? raw["id"] : `#${String(index + 1)}`);
   const type = typeOf(raw, at);
-  const spec = type.value === undefined ? failed<CustomSpec>() : specOf(raw, type.value, at, context.baseDir);
-  const needs = needsOf(raw, type.value ?? "", at);
-  const severity = severityOf(raw["level"], at);
-  const texts = textsOf(raw, at);
-  const languages = languagesOf(raw["languages"], at);
+  const checks: Checks = {
+    id,
+    spec: type.value === undefined ? failed<CustomSpec>() : specOf(raw, type.value, at, context.baseDir),
+    needs: needsOf(raw, type.value ?? "", at),
+    levels: levelsOf(raw, at),
+    texts: textsOf(raw, at),
+    languages: languagesOf(raw["languages"], at),
+    described: describedOf(raw, at, context.genres),
+  };
+  const { texts, languages } = checks;
   const examples = texts.value === undefined ? {} : examplesOf(texts.value, languages.value);
   const unpaired: CustomProblem[] = texts.value !== undefined && Object.keys(examples).length === 0 ? [{ kind: "unpaired-example", at }] : [];
-  const problems = [...[id, type, spec, needs, severity, texts, languages].flatMap((checked) => checked.problems), ...unpaired];
-  if (problems.length > 0) return failed(...problems);
-  if (id.value === undefined || spec.value === undefined || needs.value === undefined || severity.value === undefined || texts.value === undefined)
-    return failed();
-  const parts = { spec: spec.value, needs: needs.value, severity: severity.value, texts: texts.value, languages: languages.value, examples };
-  return ok(definitionOf(id.value, raw, parts, context.useFor));
+  const ordered: Checked<unknown>[] = [id, type, checks.spec, checks.needs, checks.levels, texts, languages, checks.described];
+  const problems = [...ordered.flatMap((checked) => checked.problems), ...unpaired];
+  const ready = problems.length > 0 ? undefined : partsOf(checks, examples);
+  return ready === undefined ? failed(...problems) : ok(definitionOf(ready.id, raw, ready.parts, context.useFor));
 };
 
 /** custom_rules as written. Every problem is reported; a rule with a problem is left out, and the run is stopped by the caller. */

package/src/custom/problems.ts

@@ -5,10 +5,13 @@ import { customRulesOf } from "./load.ts";
 import { MAX_PATTERN_LENGTH, MAX_REPEATS, type RegexRefusal } from "./regex-safety.ts";
 import { POS_WRITTEN_NAMES } from "./token-pattern.ts";
 import type { ModulePathRefusal } from "./module-path.ts";
+import { fieldProblemSentence, type FieldKind, type FieldProblem } from "../rule-fields.ts";
 
 /** Each problem's sentence, with {at}, {written}, {field}, {index}, {refusal} and {names} filled in from the problem. */
 type Text = {
-  readonly problems: Readonly<Record<CustomProblem["kind"], string>>;
+  readonly problems: Readonly<Record<Exclude<CustomProblem["kind"], FieldKind>, string>>;
+  /** What comes before a shared field's own sentence (rule-fields.ts). */
+  readonly fieldAt: string;
   readonly refusal: Readonly<Record<RegexRefusal, string>>;
   readonly modulePath: Readonly<Record<ModulePathRefusal, string>>;
 };
@@ -45,7 +48,11 @@ const TEXT: Texts<Text> = {
       "bad-token": "{scope} の {at}: tokens の {index} 番目に pos・base・surface のどれもありません",
       "unknown-pos": "{scope} の {at}: 品詞 {written} は知りません（{names}）",
       "bad-pattern": "{scope} の {at}: pattern を使えません。{refusal}",
+      "level-and-levels": "{scope} の {at}: level と levels の両方があります。どちらか一つにしてください",
+      "bad-levels":
+        "{scope} の {at}: levels: {written} は読めません。strict・normal・relaxed に重さ（error / warning / info）を書き、normal は必ず書きます。チームのルールは箇所を出すので、数は書けません",
     },
+    fieldAt: "{scope} の {at}: ",
   },
   en: {
     modulePath: {
@@ -78,7 +85,11 @@ const TEXT: Texts<Text> = {
       "bad-token": "{scope} {at}: token {index} has none of pos, base and surface",
       "unknown-pos": "{scope} {at}: unknown part of speech {written} ({names})",
       "bad-pattern": "{scope} {at}: the pattern cannot be used: {refusal}",
+      "level-and-levels": "{scope} {at}: has both level and levels; keep one",
+      "bad-levels":
+        "{scope} {at}: cannot read levels: {written}. Give strict, normal and relaxed a severity (error / warning / info), normal always. A team's rule reports places, so a number has nothing to count",
     },
+    fieldAt: "{scope} {at}: ",
   },
 };
 
@@ -100,10 +111,15 @@ const valuesOf = (problem: CustomProblem, text: Text, scope: string): Readonly<R
   names: POS_WRITTEN_NAMES.join(" / "),
 });
 
+const FIELD_KINDS: ReadonlySet<string> = new Set<FieldKind>(["bad-depth", "bad-group", "bad-use-for", "bad-summary", "bad-example"]);
+
+const isFieldProblem = (problem: CustomProblem): problem is FieldProblem & { readonly at: string } => FIELD_KINDS.has(problem.kind);
+
 /** One problem as a sentence. scope names the list the rule is in: custom_rules, or a plugin's rules. */
 export const customProblemSentence = (problem: CustomProblem, ui: UiLanguage, scope = "custom_rules"): string => {
   const values = valuesOf(problem, TEXT[ui], scope);
-  return TEXT[ui].problems[problem.kind].replace(PLACEHOLDER, (_whole, key: string) => values[key] ?? "");
+  const fill = (template: string): string => template.replace(PLACEHOLDER, (_whole, key: string) => values[key] ?? "");
+  return isFieldProblem(problem) ? `${fill(TEXT[ui].fieldAt)}${fieldProblemSentence(problem, ui)}` : fill(TEXT[ui].problems[problem.kind]);
 };
 
 /** What in custom_rules cannot run. Each stops the run: a team's rule that silently does not run looks like a clean document. */

package/src/date-format.ts

@@ -0,0 +1,123 @@
+// 日付の書き方（2026-10-02、2026年10月2日、Oct 2, 2026）を読む。純粋な関数だけを置く。
+// 月の名前と元号は言語パッケージの語彙表が渡す。年・月・日のそろった日付だけを読む（年だけ、月日だけは書き方を比べられない）。
+
+/** 見つけた日付 1 つ。offset は渡した文字列の中の位置、style は書き方の名前。 */
+export type WrittenDate = { readonly offset: number; readonly written: string; readonly style: string };
+
+/** 書き方を読むのに要る語。months は月の名前（January、Jan）、eras は元号（令和）。 */
+export type DateWords = { readonly months: readonly string[]; readonly eras: readonly string[] };
+
+const DIGIT = "[0-9０-９]";
+/** 日付の前に来ない字。URL や版（v1.2.2026.10）の中の数を日付と読まない。 */
+const NOT_AFTER = "(?<![\\w/.\\-])";
+
+const escaped = (word: string): string => word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+type Shape = readonly [string, RegExp];
+
+/** 日付の後ろに来ない字。時刻の付いた日時（2026-10-02T12:00）とファイルの名前（2026-10-02.pdf）は日付の書き方ではない。 */
+const NOT_BEFORE = "(?![\\w/／\\-]|\\.\\w)";
+
+const Y = `(?<y>${DIGIT}{4})`;
+const M = `(?<m>${DIGIT}{1,2})`;
+const D = `(?<d>${DIGIT}{1,2})`;
+
+/** 書き方の名前と、それを読む形。数字の組は月と日の範囲を後で確かめる。全角の数字も読む。 */
+const numericShapes = (): Shape[] => [
+  ["iso", new RegExp(`${NOT_AFTER}${Y}-${M}-${D}${NOT_BEFORE}`, "gu")],
+  ["year-slash", new RegExp(`${NOT_AFTER}${Y}[/／]${M}[/／]${D}${NOT_BEFORE}`, "gu")],
+  ["year-dot", new RegExp(`${NOT_AFTER}${Y}\\.${M}\\.${D}(?!\\.?[\\d０-９])`, "gu")],
+  ["slash-year-last", new RegExp(`${NOT_AFTER}${M}[/／]${D}[/／]${Y}${NOT_BEFORE}`, "gu")],
+  ["nen-gappi", new RegExp(`${Y}年\\s?${M}月\\s?${D}日`, "gu")],
+];
+
+const monthShapes = (months: string): Shape[] =>
+  months === ""
+    ? []
+    : [
+        ["month-day-year", new RegExp(`\\b(?:${months})\\.?\\s+(?<d>\\d{1,2})(?:st|nd|rd|th)?,?\\s+\\d{4}\\b`, "gu")],
+        ["day-month-year", new RegExp(`\\b(?<d>\\d{1,2})(?:st|nd|rd|th)?\\s+(?:${months})\\.?,?\\s+\\d{4}\\b`, "gu")],
+      ];
+
+const eraShapes = (eras: string): Shape[] => (eras === "" ? [] : [["era", new RegExp(`(?:${eras})\\s?(?:${DIGIT}{1,2}|元)年\\s?${M}月\\s?${D}日`, "gu")]]);
+
+/** 語彙表の語を使う形。月の名前は書いたとおりに照らす（小文字の may は月ではない）。 */
+const namedShapes = (words: DateWords): Shape[] => [...monthShapes(words.months.map(escaped).join("|")), ...eraShapes(words.eras.map(escaped).join("|"))];
+
+const FULLWIDTH_OFFSET = 0xfee0;
+const halfWidth = (text: string): string => text.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+const MONTHS_IN_YEAR = 12;
+const PERCENT = 100;
+const DAYS_IN_MONTH = 31;
+
+type Groups = Readonly<Record<string, string | undefined>> | undefined;
+
+const numberIn = (groups: Groups, name: string): number => Number(halfWidth(groups?.[name] ?? ""));
+
+const isMonthDay = (month: number, day: number): boolean => month >= 1 && month <= MONTHS_IN_YEAR && day >= 1 && day <= DAYS_IN_MONTH;
+
+/** 数字の組が月と日として読めるか。読めなければ版や番号（2026.10.45）。 */
+const isCalendar = (groups: Groups): boolean => isMonthDay(numberIn(groups, "m"), numberIn(groups, "d"));
+
+/** 月の名前で書いた日付の日。月は名前で決まる。 */
+const isDay = (groups: Groups): boolean => isMonthDay(1, numberIn(groups, "d"));
+
+/** 年が後ろの数字の組（10/2/2026、25/12/2026）。月日の順は国で違うので、どちらの順でも読めればよい。 */
+const isEitherOrder = (groups: Groups): boolean =>
+  isMonthDay(numberIn(groups, "m"), numberIn(groups, "d")) || isMonthDay(numberIn(groups, "d"), numberIn(groups, "m"));
+
+/** 書き方ごとの、数が月と日として読めるかの確かめ。 */
+const CHECKS: Readonly<Record<string, (groups: Groups) => boolean>> = {
+  iso: isCalendar,
+  "year-slash": isCalendar,
+  "year-dot": isCalendar,
+  "nen-gappi": isCalendar,
+  "slash-year-last": isEitherOrder,
+  era: isCalendar,
+  "month-day-year": isDay,
+  "day-month-year": isDay,
+};
+
+const found = (style: string, pattern: RegExp, text: string): WrittenDate[] => {
+  const check = CHECKS[style];
+  return [...text.matchAll(pattern)].flatMap((match) => (check?.(match.groups) === true ? [{ offset: match.index, written: match[0], style }] : []));
+};
+
+/** 文字列の中の日付と、その書き方。形どうしは同じ所に当たらない（区切りの字と、前後に来ない字が違う）。 */
+export const datesIn = (text: string, words: DateWords): WrittenDate[] =>
+  [
+    ...numericShapes().flatMap(([style, pattern]) => found(style, pattern, text)),
+    ...namedShapes(words).flatMap(([style, pattern]) => found(style, pattern, text)),
+  ].toSorted((left, right) => left.offset - right.offset);
+
+/** 少ないほうの書き方の日付と、多いほうの書き方の数と例。 */
+export type DateMinority = { readonly odd: readonly WrittenDate[]; readonly majority: WrittenDate; readonly count: number; readonly total: number };
+
+/**
+ * 書き方の多いほうと、それ以外の日付。ほかの書き方の日付の割合が limit パーセント以下のときだけ。
+ * それより多ければ、二つの書き方を使い分けている文書と読む（表は 2026-10-02、本文は 2026年10月2日）。いちばん多い書き方が同じ数で並べば言わない。
+ */
+export const dateMinority = (dates: readonly WrittenDate[], limit: number): DateMinority | undefined => {
+  const counts = new Map<string, number>();
+  dates.forEach((date) => counts.set(date.style, (counts.get(date.style) ?? 0) + 1));
+  const [top, second] = [...counts].toSorted((left, right) => right[1] - left[1]);
+  if (top === undefined || second === undefined || top[1] === second[1]) return undefined;
+  const odd = dates.filter((date) => date.style !== top[0]);
+  const majority = dates.find((date) => date.style === top[0]);
+  if (majority === undefined || odd.length * PERCENT > dates.length * limit) return undefined;
+  return { odd, majority, count: top[1], total: dates.length };
+};
+
+/** 行の頭から日付までが、箇条書きの印・表の区切り・強調の印と空白だけ。予定表の行の頭の日付（- 2026-10-16: …、| 2026-10-16 |）。 */
+const LINE_HEAD = /(?:^|\|)[\s>*_+-]*(?:\d+[.)]\s+)?$/u;
+
+/** 日付が行の頭（箇条書きの項目や表の升の頭）にあるか。 */
+export const opensLine = (text: string, offset: number): boolean => LINE_HEAD.test(text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset));
+
+/**
+ * 行の頭の日付と、文の中の日付を分ける。予定表を 2026-10-16 で並べ、文では 14 October 2026 と書くのは使い分けで、混ざりではない。
+ * 書き方はそれぞれの組の中でだけ比べる。
+ */
+export const dateGroups = (text: string, dates: readonly WrittenDate[]): WrittenDate[][] =>
+  [true, false].map((head) => dates.filter((date) => opensLine(text, date.offset) === head)).filter((group) => group.length > 0);

package/src/derived/date-arithmetic.ts

@@ -0,0 +1,63 @@
+/**
+ * 木の日付の値（2026-04-01、04-01、2026-04、2026）に期間を足す。年の無い月日は、同じ年の中で数える（年をまたげば翌年）。
+ * 暦は先発グレゴリオ暦。月を足して月末を越えるとき（1月31日の1か月後）は、その月の末日にする。
+ */
+export type DurationUnit = "day" | "week" | "month" | "year";
+
+export type CalendarDate = { readonly year: number | undefined; readonly month: number; readonly day: number };
+
+const FULL = /^(\d{4})-(\d{2})-(\d{2})$/u;
+const MONTH_DAY = /^(\d{2})-(\d{2})$/u;
+const YEAR_ONLY = /^(\d{4})$/u;
+const FULL_YEAR = /^(\d{4})-\d{2}(?:-\d{2})?$/u;
+
+/** 年がわからない月日を数えるときの年。うるう年でない年にすると 2月29日 が読めないので、うるう年を使う。 */
+const LEAP_YEAR = 2000;
+const DAYS_IN_WEEK = 7;
+const MONTHS_IN_YEAR = 12;
+const PADDED = 2;
+
+/** 年月日か月日の値。それ以外（年月、年だけ）は undefined。 */
+export const calendarDateOf = (value: string): CalendarDate | undefined => {
+  const full = FULL.exec(value);
+  if (full !== null) return { year: Number(full[1]), month: Number(full[2]), day: Number(full[3]) };
+  const monthDay = MONTH_DAY.exec(value);
+  return monthDay === null ? undefined : { year: undefined, month: Number(monthDay[1]), day: Number(monthDay[2]) };
+};
+
+/** 年を書いた値（2015、2015-04、2015-04-01）の年。 */
+export const yearOf = (value: string): number | undefined => {
+  const year = YEAR_ONLY.exec(value) ?? FULL_YEAR.exec(value);
+  return year === null ? undefined : Number(year[1]);
+};
+
+const utcOf = (year: number, month: number, day: number): Date => new Date(Date.UTC(year, month - 1, day));
+
+const lastDayOf = (year: number, month: number): number => utcOf(year, month + 1, 0).getUTCDate();
+
+const addMonths = (date: Date, months: number): Date => {
+  const target = utcOf(date.getUTCFullYear(), date.getUTCMonth() + 1 + months, 1);
+  const day = Math.min(date.getUTCDate(), lastDayOf(target.getUTCFullYear(), target.getUTCMonth() + 1));
+  return utcOf(target.getUTCFullYear(), target.getUTCMonth() + 1, day);
+};
+
+const addDays = (date: Date, days: number): Date => utcOf(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate() + days);
+
+/** 日付に期間を足す（負なら引く）。 */
+export const shifted = (date: Date, amount: number, unit: DurationUnit): Date => {
+  if (unit === "day") return addDays(date, amount);
+  if (unit === "week") return addDays(date, amount * DAYS_IN_WEEK);
+  return addMonths(date, unit === "month" ? amount : amount * MONTHS_IN_YEAR);
+};
+
+/** 年の無い月日には仮の年を付ける。 */
+export const dateOf = (date: CalendarDate): Date => utcOf(date.year ?? LEAP_YEAR, date.month, date.day);
+
+export const sameDay = (left: Date, right: Date): boolean => left.getTime() === right.getTime();
+
+/** 日付を、元の値と同じ細かさの値（年が無ければ月日だけ）にする。 */
+export const valueOf = (date: Date, withYear: boolean): string => {
+  const month = String(date.getUTCMonth() + 1).padStart(PADDED, "0");
+  const day = String(date.getUTCDate()).padStart(PADDED, "0");
+  return withYear ? `${String(date.getUTCFullYear())}-${month}-${day}` : `${month}-${day}`;
+};

package/src/derived/durations.ts

@@ -0,0 +1,52 @@
+import type { Span } from "../plugin.ts";
+import { bySentence } from "./sentence-buckets.ts";
+import { calendarDateOf, dateOf, shifted, valueOf, type DurationUnit } from "./date-arithmetic.ts";
+
+/**
+ * 始まりと期間と終わりを一つの文に書いたもの（「4月1日から3か月間（6月30日まで）」"for 3 months from April 1, 2026 (until
+ * June 30, 2026)"）。始まりに期間を足した日が終わりと合わなければ言う。期間の数え方は三通りある。終わりの日を含めて数える
+ * （4月1日から3か月間は6月30日まで）か、含めずに数える（7月1日まで）か、初日を数えずに期間が過ぎた日（「到達日から2週間が経過した日
+ * （4月16日）」）。どれとも合わないときだけ言う。
+ * 文に日付がちょうど二つ、期間がちょうど一つのときだけ読む。それより多い文は、どの日付とどの期間が組なのか決まらない。
+ */
+export type DatedValue = Span & { readonly value: string };
+
+export type Duration = Span & { readonly amount: number; readonly unit: DurationUnit };
+
+export type DurationMismatch = { readonly start: DatedValue; readonly duration: Duration; readonly end: DatedValue; readonly expected: string };
+
+/** 期間を足した日と、その前の日（終わりを含めて数える）と、次の日（初日を数えずに期間が過ぎた日）。 */
+const expectedEnds = (start: Date, duration: Duration): Date[] => {
+  const exclusive = shifted(start, duration.amount, duration.unit);
+  return [shifted(exclusive, -1, "day"), exclusive, shifted(exclusive, 1, "day")];
+};
+
+/** 年まで書いた二つの日付は、早いほうを始まりにする（「7月1日まで、4月1日から3か月」）。月日だけなら書いた順（年をまたぐことがある）。 */
+const ordered = (first: DatedValue, second: DatedValue, withYear: boolean): [DatedValue, DatedValue] =>
+  withYear && second.value < first.value ? [second, first] : [first, second];
+
+const mismatchOf = (written: readonly [DatedValue, DatedValue], duration: Duration): DurationMismatch | undefined => {
+  const [firstDate, secondDate] = [calendarDateOf(written[0].value), calendarDateOf(written[1].value)];
+  if (firstDate === undefined || secondDate === undefined || (firstDate.year === undefined) !== (secondDate.year === undefined)) return undefined;
+  const withYear = firstDate.year !== undefined;
+  const [start, end] = ordered(written[0], written[1], withYear);
+  const startDate = calendarDateOf(start.value);
+  if (startDate === undefined) return undefined;
+  const ends = expectedEnds(dateOf(startDate), duration);
+  const [inclusive] = ends;
+  if (inclusive === undefined || ends.some((candidate) => valueOf(candidate, withYear) === end.value)) return undefined;
+  return { start, duration, end, expected: valueOf(inclusive, withYear) };
+};
+
+/** 一つの文の中の、始まり・期間・終わり。 */
+export const durationMismatches = (sentences: readonly Span[], dates: readonly DatedValue[], durations: readonly Duration[]): DurationMismatch[] => {
+  const datesIn = bySentence(sentences, dates);
+  return [...bySentence(sentences, durations).entries()].flatMap(([index, inDurations]) => {
+    const inDates = datesIn.get(index) ?? [];
+    const [first, second] = inDates;
+    const [duration] = inDurations;
+    if (inDates.length !== 2 || inDurations.length !== 1 || first === undefined || second === undefined || duration === undefined) return [];
+    const mismatch = mismatchOf([first, second], duration);
+    return mismatch === undefined ? [] : [mismatch];
+  });
+};