chaffjs 0.18.0 → 0.19.0

package/src/config/style.ts

@@ -18,13 +18,26 @@ export const withStyle = (config: Config, styles: readonly StyleDefinition[]): C
   const style = styles.find((entry) => entry.id === config.style);
   if (style === undefined) return config;
   const fromStyle = Object.keys(style.rules).filter((id) => config.rules[id] === undefined && config.limits[id] === undefined);
+  const limits = Object.fromEntries(Object.entries(style.limits).filter(([id]) => fromStyle.includes(id)));
   return {
     ...config,
     rules: { ...style.rules, ...config.rules },
-    applied: { style: style.id, levelsFrom: fromStyle, options: style.options },
+    applied: { style: style.id, levelsFrom: fromStyle, options: style.options, limits },
   };
 };
 
+/**
+ * The numeric limits a run of a document in this language uses: chaff.yaml's own, and under them the style's for this
+ * language. A style that gives a number only for Japanese leaves an English document at the level's number.
+ */
+export const limitsFor = (config: Pick<Config, "limits" | "applied">, language: string): Readonly<Record<string, number>> => {
+  const fromStyle = Object.entries(config.applied?.limits ?? {}).flatMap(([id, byLanguage]): [string, number][] => {
+    const limit = byLanguage[language];
+    return limit === undefined ? [] : [[id, limit]];
+  });
+  return { ...Object.fromEntries(fromStyle), ...config.limits };
+};
+
 const TEXT: Texts<{ readonly unknown: (where: string, style: string, known: string) => string }> = {
   ja: {
     unknown: (where, style, known) => `${where}: style: ${style} というスタイルはありません。使えるのは ${known} です`,

package/src/custom/load.ts

@@ -5,11 +5,19 @@ import { loadGenres } from "../genre-load.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. */
-export const customRulesOf = (config: Pick<Config, "customRules">): CustomRules =>
+export const customRulesOf = (config: Pick<Config, "customRules" | "baseDir">): CustomRules =>
   parseCustomRules(config.customRules, {
     builtIn: new Set(loadRules("en").map((rule) => rule.id)),
     useFor: loadGenres().groups.map((group) => group.id),
+    baseDir: config.baseDir,
   });
 
-/** Every rule a run knows for a language: chaff's own, then the team's. Where the team's cannot be read, settingProblems stops the run. */
-export const rulesOf = (language: string, config: Pick<Config, "customRules">): RuleDefinition[] => [...loadRules(language), ...customRulesOf(config).rules];
+/**
+ * Every rule a run knows for a language: chaff's own, the team's, then the plugins'. Where the team's or a plugin's
+ * cannot be read, settingProblems stops the run.
+ */
+export const rulesOf = (language: string, config: Pick<Config, "customRules" | "baseDir" | "extensions">): RuleDefinition[] => [
+  ...loadRules(language),
+  ...customRulesOf(config).rules,
+  ...(config.extensions?.rules ?? []),
+];

package/src/custom/module-path.ts

@@ -0,0 +1,23 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+
+// Where a type: module rule's file is. Loading it runs its code, so a relative path may not leave the folder chaff.yaml
+// is in: a chaff.yaml copied from elsewhere cannot reach for ../../somewhere. An absolute path is written on purpose and
+// is used as written. Pure: no file is read.
+
+export type ModulePathRefusal = "outside";
+
+export type ModulePath = { readonly file: string } | { readonly refusal: ModulePathRefusal };
+
+/** Whether file is inside dir (dir itself is not). Reads no file: the same check runs on real paths at load time. */
+export const isInside = (dir: string, file: string): boolean => {
+  const fromDir = relative(dir, file);
+  const leaves = fromDir === ".." || fromDir.startsWith(`..${sep}`);
+  return fromDir !== "" && !leaves && !isAbsolute(fromDir);
+};
+
+/** The file a module path names, relative to baseDir (where chaff.yaml is) unless it is absolute. */
+export const modulePathOf = (written: string, baseDir: string): ModulePath => {
+  if (isAbsolute(written)) return { file: written };
+  const file = resolve(baseDir, written);
+  return isInside(baseDir, file) ? { file } : { refusal: "outside" };
+};

package/src/custom/parse.ts

@@ -1,14 +1,12 @@
 import type { CustomSpec, LevelTable, Localized, RuleDefinition, Severity, 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";
 
 // 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.
 
-export const CUSTOM_TYPES = ["words", "pattern", "tokens"] as const;
-
-/** Reserved for a small Node function a team writes. Refused with its own message until it is supported. */
-const RESERVED_TYPES: readonly string[] = ["module"];
+export const CUSTOM_TYPES = ["words", "pattern", "tokens", "module"] as const;
 
 export type CustomProblem =
   | { readonly kind: "not-a-list" }
@@ -17,7 +15,9 @@ export type CustomProblem =
   | { readonly kind: "duplicate-id"; readonly at: string }
   | { readonly kind: "built-in-id"; readonly at: string }
   | { readonly kind: "unknown-type"; readonly at: string; readonly written: string }
-  | { readonly kind: "not-yet"; readonly at: string; readonly written: string }
+  | { readonly kind: "bad-module"; readonly at: string; readonly written: string; readonly refusal: ModulePathRefusal }
+  | { readonly kind: "bad-requires"; readonly at: string; readonly written: string }
+  | { readonly kind: "bad-word-list"; readonly at: string; readonly written: string }
   | { readonly kind: "missing"; readonly at: string; readonly field: string }
   | { readonly kind: "unpaired-example"; readonly at: string }
   | { readonly kind: "bad-level"; readonly at: string; readonly written: string }
@@ -30,8 +30,11 @@ export type CustomProblem =
 
 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) and the genres a rule applies to. */
-export type CustomContext = { readonly builtIn: ReadonlySet<string>; readonly useFor: readonly string[] };
+/**
+ * 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).
+ */
+export type CustomContext = { readonly builtIn: ReadonlySet<string>; readonly useFor: readonly string[]; readonly baseDir: string };
 
 const RULE_ID = /^[a-z][a-z0-9-]*$/u;
 const SEVERITIES: readonly Severity[] = ["info", "warning", "error"];
@@ -113,16 +116,24 @@ const tokensOf = (raw: unknown, at: string): Checked<CustomSpec> => {
   return problems.length > 0 ? failed(...problems) : ok({ type: "tokens", tokens });
 };
 
-const specOf = (raw: Record<string, unknown>, type: string, at: string): Checked<CustomSpec> => {
+const moduleOf = (raw: Record<string, unknown>, at: string, baseDir: string): Checked<CustomSpec> => {
+  const written = raw["module"];
+  if (!nonEmpty(written)) return failed({ kind: "missing", at, field: "module" });
+  const path = modulePathOf(written.trim(), baseDir);
+  if ("refusal" in path) return failed({ kind: "bad-module", at, written, refusal: path.refusal });
+  return ok({ type: "module", module: written.trim(), file: path.file });
+};
+
+const specOf = (raw: Record<string, unknown>, type: string, at: string, baseDir: string): Checked<CustomSpec> => {
   if (type === "words") return wordsOf(raw["words"], at);
   if (type === "pattern") return patternOf(raw, at);
+  if (type === "module") return moduleOf(raw, at, baseDir);
   return tokensOf(raw["tokens"], at);
 };
 
 const typeOf = (raw: Record<string, unknown>, at: string): Checked<string> => {
   const type = raw["type"];
   if (!nonEmpty(type)) return failed({ kind: "missing", at, field: "type" });
-  if (RESERVED_TYPES.includes(type)) return failed({ kind: "not-yet", at, written: type });
   return CUSTOM_TYPES.some((known) => known === type) ? ok(type) : failed({ kind: "unknown-type", at, written: type });
 };
 
@@ -157,6 +168,33 @@ const textsOf = (raw: Record<string, unknown>, at: string): Checked<Texts> => {
   return ok({ name, why, how_to_fix: howToFix, before, after });
 };
 
+/** What a module's detector may ask the adapter for. Only parts of speech: without them, sentences have no tokens. */
+const REQUIRABLE: readonly string[] = ["pos"];
+
+const requiresOf = (raw: unknown, type: string, at: string): Checked<readonly string[]> => {
+  if (type === "tokens") return ok(["pos"]);
+  if (raw === undefined || type !== "module") return ok([]);
+  const written = (Array.isArray(raw) ? raw : [raw]).map((entry: unknown) => (typeof entry === "string" ? entry : printed(entry)));
+  const unknown = written.find((need) => !REQUIRABLE.includes(need));
+  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);
+  return nonEmpty(raw) ? ok(raw.trim()) : failed({ kind: "bad-word-list", at, written: printed(raw) });
+};
+
+/** What a rule's detector needs besides the document: tokens from the adapter, and a word list. */
+type Needs = { readonly requires: readonly string[]; readonly wordList: string | undefined };
+
+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);
+  if (requires.value === undefined || wordList.problems.length > 0) return failed(...requires.problems, ...wordList.problems);
+  return ok({ requires: requires.value, wordList: wordList.value });
+};
+
 const languagesOf = (raw: unknown, at: string): Checked<readonly string[] | undefined> => {
   if (raw === undefined) return ok(undefined);
   const list = Array.isArray(raw) ? raw : [raw];
@@ -175,12 +213,19 @@ const PLACEHOLDERS: Readonly<Record<string, Localized>> = {
   preferred: { ja: "使う書き方", en: "the spelling to use" },
 };
 
-const HOW_TO_FIND: Readonly<Record<CustomSpec["type"], string>> = { words: "custom-words", pattern: "custom-pattern", tokens: "custom-tokens" };
+/** A module's detector is not in chaff's table: it is loaded from the module and found by the rule's id. */
+const HOW_TO_FIND: Readonly<Record<CustomSpec["type"], string>> = {
+  words: "custom-words",
+  pattern: "custom-pattern",
+  tokens: "custom-tokens",
+  module: "module",
+};
 
 type Example = { readonly before: string; readonly after: string };
 
 type Parts = {
   readonly spec: CustomSpec;
+  readonly needs: Needs;
   readonly severity: Severity;
   readonly texts: Texts;
   readonly languages: readonly string[] | undefined;
@@ -200,7 +245,7 @@ const examplesOf = (texts: Texts, languages: readonly string[] | undefined): Rec
 
 const definitionOf = (id: string, raw: Record<string, unknown>, parts: Parts, useFor: readonly string[]): RuleDefinition => ({
   id,
-  layer: parts.spec.type === "tokens" ? "L3" : "L2",
+  layer: parts.needs.requires.includes("pos") ? "L3" : "L2",
   status: "stable",
   name: parts.texts.name,
   why: parts.texts.why,
@@ -212,12 +257,12 @@ const definitionOf = (id: string, raw: Record<string, unknown>, parts: Parts, us
   level_sets: "severity",
   by_genre: {},
   how_to_find: HOW_TO_FIND[parts.spec.type],
-  word_list: undefined,
+  word_list: parts.needs.wordList,
   extra_word_lists: [],
   what_to_check: undefined,
   where: undefined,
   full_sentence: undefined,
-  requires: parts.spec.type === "tokens" ? ["pos"] : [],
+  requires: parts.needs.requires,
   uses: [],
   from: [],
   languages: parts.languages,
@@ -231,6 +276,8 @@ const definitionOf = (id: string, raw: Record<string, unknown>, parts: Parts, us
     examples: parts.examples,
     notFlagged: {},
     levelMeaning: {},
+    sources: [],
+    rewrite: {},
   },
 });
 
@@ -247,16 +294,18 @@ const ruleOf = (raw: unknown, index: number, seen: ReadonlySet<string>, context:
   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);
+  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 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, severity, texts, languages].flatMap((checked) => checked.problems), ...unpaired];
-  if (id.value === undefined || spec.value === undefined || severity.value === undefined || texts.value === undefined || problems.length > 0)
-    return failed(...problems);
-  const parts = { spec: spec.value, severity: severity.value, texts: texts.value, languages: languages.value, examples };
+  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));
 };
 

package/src/custom/problems.ts

@@ -4,12 +4,20 @@ import type { CustomProblem } from "./parse.ts";
 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";
 
 /** 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 refusal: Readonly<Record<RegexRefusal, string>> };
+type Text = {
+  readonly problems: Readonly<Record<CustomProblem["kind"], string>>;
+  readonly refusal: Readonly<Record<RegexRefusal, string>>;
+  readonly modulePath: Readonly<Record<ModulePathRefusal, string>>;
+};
 
 const TEXT: Texts<Text> = {
   ja: {
+    modulePath: {
+      outside: "chaff.yaml のあるフォルダの外です。読み込むとそのコードが動くので、外のファイルは絶対パスで名指ししてください",
+    },
     refusal: {
       "too-long": `${String(MAX_PATTERN_LENGTH)} 字を超えています。いくつかのルールに分けてください`,
       "nested-quantifier": "繰り返しの中に繰り返しがあります（(a+)+ のような形）。長い行で止まらなくなるので使えません",
@@ -19,25 +27,30 @@ const TEXT: Texts<Text> = {
       invalid: "正規表現として読めません",
     },
     problems: {
-      "not-a-list": "custom_rules はルールの並び（- id: …）で書いてください",
-      "not-a-map": "custom_rules の {at}: id や type を持つ項目として書いてください",
-      "bad-id": "custom_rules の {at}: id は英小文字で始まり、英小文字・数字・ハイフンだけで書きます（例: team-no-tbd）",
-      "duplicate-id": "custom_rules の {at}: 同じ id のルールがもう一つあります",
-      "built-in-id": "custom_rules の {at}: chaff のルールと同じ id です。別の id にしてください",
-      "unknown-type": "custom_rules の {at}: type: {written} は使えません（words / pattern / tokens）",
-      "not-yet": "custom_rules の {at}: type: {written} はまだ使えません（words / pattern / tokens）",
-      missing: "custom_rules の {at}: {field} がありません",
-      "unpaired-example": "custom_rules の {at}: example の before と after を、ルールが見る言語の同じ言語で書いてください",
-      "bad-level": "custom_rules の {at}: level: {written} は読めません（error / warning / info）",
-      "bad-languages": "custom_rules の {at}: languages は言語の並びで書いてください（[ja] や [ja, en]）",
-      "no-words": "custom_rules の {at}: words に語がありません（「使わない書き方: 使う書き方」か語の並び）",
-      "no-tokens": "custom_rules の {at}: tokens に語の条件がありません（- { pos: 名詞 } のように並べます）",
-      "bad-token": "custom_rules の {at}: tokens の {index} 番目に pos・base・surface のどれもありません",
-      "unknown-pos": "custom_rules の {at}: 品詞 {written} は知りません（{names}）",
-      "bad-pattern": "custom_rules の {at}: pattern を使えません。{refusal}",
+      "not-a-list": "{scope} はルールの並び（- id: …）で書いてください",
+      "not-a-map": "{scope} の {at}: id や type を持つ項目として書いてください",
+      "bad-id": "{scope} の {at}: id は英小文字で始まり、英小文字・数字・ハイフンだけで書きます（例: team-no-tbd）",
+      "duplicate-id": "{scope} の {at}: 同じ id のルールがもう一つあります",
+      "built-in-id": "{scope} の {at}: chaff のルールと同じ id です。別の id にしてください",
+      "unknown-type": "{scope} の {at}: type: {written} は使えません（words / pattern / tokens / module）",
+      "bad-module": "{scope} の {at}: module: {written} は使えません。{refusal}",
+      "bad-requires": "{scope} の {at}: requires: {written} は求められません（求められるのは pos だけです）",
+      "bad-word-list": "{scope} の {at}: word_list: {written} は語彙表の名前として読めません",
+      missing: "{scope} の {at}: {field} がありません",
+      "unpaired-example": "{scope} の {at}: example の before と after を、ルールが見る言語の同じ言語で書いてください",
+      "bad-level": "{scope} の {at}: level: {written} は読めません（error / warning / info）",
+      "bad-languages": "{scope} の {at}: languages は言語の並びで書いてください（[ja] や [ja, en]）",
+      "no-words": "{scope} の {at}: words に語がありません（「使わない書き方: 使う書き方」か語の並び）",
+      "no-tokens": "{scope} の {at}: tokens に語の条件がありません（- { pos: 名詞 } のように並べます）",
+      "bad-token": "{scope} の {at}: tokens の {index} 番目に pos・base・surface のどれもありません",
+      "unknown-pos": "{scope} の {at}: 品詞 {written} は知りません（{names}）",
+      "bad-pattern": "{scope} の {at}: pattern を使えません。{refusal}",
     },
   },
   en: {
+    modulePath: {
+      outside: "it is outside the folder chaff.yaml is in. Loading a module runs its code, so name a file outside by its absolute path",
+    },
     refusal: {
       "too-long": `it is longer than ${String(MAX_PATTERN_LENGTH)} characters; split it into several rules`,
       "nested-quantifier": "it repeats something that repeats (a shape like (a+)+), which can run for minutes on a long line",
@@ -47,43 +60,52 @@ const TEXT: Texts<Text> = {
       invalid: "it is not a regular expression",
     },
     problems: {
-      "not-a-list": "write custom_rules as a list of rules (- id: …)",
-      "not-a-map": "custom_rules {at}: write each rule as an entry with id and type",
-      "bad-id": "custom_rules {at}: an id starts with a lowercase letter and has only lowercase letters, digits and hyphens (team-no-tbd)",
-      "duplicate-id": "custom_rules {at}: another rule has the same id",
-      "built-in-id": "custom_rules {at}: chaff has a rule with this id; choose another",
-      "unknown-type": "custom_rules {at}: type: {written} is not a type (words / pattern / tokens)",
-      "not-yet": "custom_rules {at}: type: {written} is not supported yet (words / pattern / tokens)",
-      missing: "custom_rules {at}: {field} is missing",
-      "unpaired-example": "custom_rules {at}: write example's before and after in the same language, one the rule checks",
-      "bad-level": "custom_rules {at}: cannot read level: {written} (error / warning / info)",
-      "bad-languages": "custom_rules {at}: write languages as a list ([en] or [ja, en])",
-      "no-words": "custom_rules {at}: words has no words (avoid: use pairs, or a list)",
-      "no-tokens": "custom_rules {at}: tokens has no conditions (- { pos: noun } and so on)",
-      "bad-token": "custom_rules {at}: token {index} has none of pos, base and surface",
-      "unknown-pos": "custom_rules {at}: unknown part of speech {written} ({names})",
-      "bad-pattern": "custom_rules {at}: the pattern cannot be used: {refusal}",
+      "not-a-list": "write {scope} as a list of rules (- id: …)",
+      "not-a-map": "{scope} {at}: write each rule as an entry with id and type",
+      "bad-id": "{scope} {at}: an id starts with a lowercase letter and has only lowercase letters, digits and hyphens (team-no-tbd)",
+      "duplicate-id": "{scope} {at}: another rule has the same id",
+      "built-in-id": "{scope} {at}: chaff has a rule with this id; choose another",
+      "unknown-type": "{scope} {at}: type: {written} is not a type (words / pattern / tokens / module)",
+      "bad-module": "{scope} {at}: module: {written} cannot be used: {refusal}",
+      "bad-requires": "{scope} {at}: requires: {written} cannot be asked for (only pos can)",
+      "bad-word-list": "{scope} {at}: cannot read word_list: {written} as the name of a word list",
+      missing: "{scope} {at}: {field} is missing",
+      "unpaired-example": "{scope} {at}: write example's before and after in the same language, one the rule checks",
+      "bad-level": "{scope} {at}: cannot read level: {written} (error / warning / info)",
+      "bad-languages": "{scope} {at}: write languages as a list ([en] or [ja, en])",
+      "no-words": "{scope} {at}: words has no words (avoid: use pairs, or a list)",
+      "no-tokens": "{scope} {at}: tokens has no conditions (- { pos: noun } and so on)",
+      "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}",
     },
   },
 };
 
-const PLACEHOLDER = /\{(at|written|field|index|refusal|names)\}/gu;
+const PLACEHOLDER = /\{(scope|at|written|field|index|refusal|names)\}/gu;
+
+const refusalOf = (problem: CustomProblem, text: Text): string => {
+  if (problem.kind === "bad-pattern") return text.refusal[problem.refusal];
+  return problem.kind === "bad-module" ? text.modulePath[problem.refusal] : "";
+};
 
 /** The values a problem's sentence names. Each kind carries only some of them. */
-const valuesOf = (problem: CustomProblem, text: Text): Readonly<Record<string, string>> => ({
+const valuesOf = (problem: CustomProblem, text: Text, scope: string): Readonly<Record<string, string>> => ({
+  scope,
   at: "at" in problem ? problem.at : "",
   written: "written" in problem ? problem.written : "",
   field: "field" in problem ? problem.field : "",
   index: "index" in problem ? String(problem.index) : "",
-  refusal: "refusal" in problem ? text.refusal[problem.refusal] : "",
+  refusal: refusalOf(problem, text),
   names: POS_WRITTEN_NAMES.join(" / "),
 });
 
-const sentenceOf = (problem: CustomProblem, text: Text): string => {
-  const values = valuesOf(problem, text);
-  return text.problems[problem.kind].replace(PLACEHOLDER, (_whole, key: string) => values[key] ?? "");
+/** 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] ?? "");
 };
 
 /** What in custom_rules cannot run. Each stops the run: a team's rule that silently does not run looks like a clean document. */
-export const customRuleProblems = (config: Pick<Config, "customRules" | "path">, ui: UiLanguage): string[] =>
-  customRulesOf(config).problems.map((problem) => `chaff: ${config.path ?? "chaff.yaml"}: ${sentenceOf(problem, TEXT[ui])}`);
+export const customRuleProblems = (config: Pick<Config, "customRules" | "path" | "baseDir">, ui: UiLanguage): string[] =>
+  customRulesOf(config).problems.map((problem) => `chaff: ${config.path ?? "chaff.yaml"}: ${customProblemSentence(problem, ui)}`);

package/src/detect-language.ts

@@ -6,7 +6,7 @@
  * 権威ある点数で、こちらは何も読み込んでいない状態での見当付け。
  * 似た計算を両方が持つのは、この順序から来る避けられない重複。
  *
- * 呼ぶ側が、コードブロック・インラインコード・URL・front matter を先に落としておくこと。
+ * 呼ぶ側が、コードブロック・インラインコード・URL・front matter を先に落としておくこと（guessLanguage は language-sample.ts で落とす）。
  * 技術文書は英語のコードを大量に含むため、落とさないと日本語文書が英語と判定される。
  */
 const JAPANESE = /[぀-ゟ゠-ヿ一-鿿]/gu;

package/src/detect.ts

@@ -5,6 +5,7 @@ import { parse } from "yaml";
 import { japaneseRatio, latinRatio } from "./detect-language.ts";
 import { referenceListSpans } from "./reference-lists.ts";
 import { withoutSpans } from "./soft-break.ts";
+import { languageSample } from "./language-sample.ts";
 
 export type LanguageGuess = { readonly language: string; readonly confidence: number; readonly from: string };
 
@@ -33,9 +34,15 @@ const bodyOf = (source: string): string => {
   return body.trim() === "" ? source : body;
 };
 
+/** The body without code, URLs and markup, or the whole body when nothing else is left (a document of only code). */
+const proseOf = (body: string): string => {
+  const sample = languageSample(body);
+  return sample.trim() === "" ? body : sample;
+};
+
 export const guessLanguage = (source: string): LanguageGuess => {
-  const body = bodyOf(source);
-  const japanese = japaneseRatio(body);
+  const prose = proseOf(bodyOf(source));
+  const japanese = japaneseRatio(prose);
   if (japanese >= JAPANESE_FLOOR) return { language: "ja", confidence: japanese, from: "content" };
-  return { language: "en", confidence: latinRatio(body), from: "content" };
+  return { language: "en", confidence: latinRatio(prose), from: "content" };
 };

package/src/detectors/ai-phrasing.ts

@@ -73,9 +73,13 @@ export const openerPile: Detector = (doc, options): Finding[] => {
   return hits.length === 0 || hits.length < options.limit ? [] : hits.map((hit) => findingOf(hit, { count: hits.length, limit: options.limit }));
 };
 
-/** コロンで箇条書きへ渡す文（以下の通りです：）。1 つなら案内だが、節ごとに続くと説明が箇条書きの前置きだけになる。 */
+/**
+ * コロンで箇条書きへ渡す文（以下の通りです：）。1 つなら案内だが、節ごとに続くと説明が箇条書きの前置きだけになる。
+ * 数えるのは文書の言語の文だけ。和文の中の英文（Examples include:）は、英語ではふつうの書き方なので数えない。
+ */
 export const colonLeadIn: Detector = (doc, options): Finding[] => {
-  const hits = colonLeadIns(doc.sentences, doc.lists, doc.listSpans, doc.source).map((sentence) => ({ sentence, matched: sentence.text.trim() }));
+  const inDocumentLanguage = doc.sentences.filter((sentence) => sentence.embeddedLanguage === undefined);
+  const hits = colonLeadIns(inDocumentLanguage, doc.lists, doc.listSpans, doc.source).map((sentence) => ({ sentence, matched: sentence.text.trim() }));
   return densityFindings(doc, hits, options.limit);
 };
 

package/src/detectors/bold-label.ts

@@ -0,0 +1,55 @@
+import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
+
+/** A bold run longer than this is a bold sentence, not a label. */
+const MAX_LABEL_CHARS = 40;
+
+/** The bullet or number that opens a list item. */
+const ITEM_MARKER = /^[ \t]*(?:[-*+]|\d{1,9}[.)])[ \t]+/u;
+
+/** A task box, after the marker or at the start of an item whose marker was already cut. */
+const TASK_BOX = /^\[[ xX]\][ \t]+/u;
+
+/** `**Label**: text` or `**Label:** text`. The label holds no delimiter, so `**a** and **b**: text` is not one label. */
+const BOLD_LABEL = new RegExp(String.raw`^(\*\*|__)(?!\s)((?:(?!\1)[^\n]){1,${MAX_LABEL_CHARS}}?)(?:\1[ \t]*[:：]|[:：]\1)[ \t]*\S`, "u");
+
+/** A label that is only code (`--flag`, `timeout_ms`) names an option or a field: the way reference documentation lists them. */
+const CODE_SPAN = /^`[^`]+`$/u;
+
+/** A link around the whole label: inline, reference, collapsed or shortcut. Its text is what the reader sees. */
+const WHOLE_LINK = /^\[([^\]\n]+)\](?:\([^)\s]*\)|\[[^\]\n]*\])?$/u;
+
+const isCodeOnly = (label: string): boolean => CODE_SPAN.test(label.replace(WHOLE_LINK, "$1"));
+
+/** The label a list item opens with in bold before a colon and more text, or undefined. `item` is the item as written, marker and all. */
+export const boldLabelOf = (item: string): string | undefined => {
+  const label = BOLD_LABEL.exec(item.replace(ITEM_MARKER, "").replace(TASK_BOX, ""))?.[2]?.trim();
+  return label === undefined || isCodeOnly(label) ? undefined : label;
+};
+
+/** Whether the line holding `offset` is quoted (`> - **a**：…`): someone else's words, not the writer's to fix. */
+export const isQuotedAt = (source: string, offset: number): boolean => source.slice(source.lastIndexOf("\n", offset - 1) + 1, offset).includes(">");
+
+/** The list items, in document order, that open with a bold label and are not quoted. */
+export const boldLabelItems = (doc: ProseDocument): Span[] =>
+  doc.lists
+    .flatMap((list) => list.itemSpans)
+    .filter((span) => !isQuotedAt(doc.source, span.start) && boldLabelOf(doc.source.slice(span.start, span.end)) !== undefined)
+    .toSorted((left, right) => left.start - right.start);
+
+/** A count, not a density: a person writes one or two labels even in a long article. */
+export const boldLabelList: Detector = (doc, options): Finding[] => {
+  const items = boldLabelItems(doc);
+  const first = items[0];
+  if (first === undefined || items.length < options.limit) return [];
+  const written = doc.source.slice(first.start, first.end);
+  return [
+    {
+      rule: "bold-label-list",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: (written.split("\n")[0] ?? "").trim(),
+      values: { label: boldLabelOf(written) ?? "", count: items.length, limit: options.limit, offset: first.start },
+    },
+  ];
+};

package/src/detectors/dangling-figure.ts

@@ -1,18 +1,22 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { danglingFigures, type LabelWords } from "../figure-references.ts";
+import { danglingFigures, type Citations, type LabelWords } from "../figure-references.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
-const labelWordsOf = (doc: ProseDocument): LabelWords => ({
+/** The language's words for figures, tables and appendices, and for a number that points elsewhere or counts. */
+export const labelWordsOf = (doc: ProseDocument): LabelWords => ({
   labels: (doc.lexicons["figure-label"] ?? []).map((entry) => ({ word: entry.pattern, kind: entry.instead_of ?? entry.pattern })),
   elsewhere: patternsOf(doc, "figure-elsewhere"),
   counters: patternsOf(doc, "count-counter"),
 });
 
-/** 本文が指す図・表・付録の番号が、キャプションにも見出しにも無い。 */
+const citationsOf = (doc: ProseDocument): Citations | undefined =>
+  doc.namedDocument === undefined ? undefined : { namedDocument: doc.namedDocument, sentences: doc.sentences.map((sentence) => sentence.span) };
+
+/** 本文が指す図・表・付録の番号が、キャプションにも見出しにも無い。他の文書の名前の後ろに書いた番号は、その文書の図。 */
 export const danglingFigure: Detector = (doc): Finding[] =>
-  danglingFigures(doc.source, doc.prose ?? doc.source, labelWordsOf(doc), doc.links).map((dangling) => ({
+  danglingFigures(doc.source, doc.prose ?? doc.source, labelWordsOf(doc), doc.links, citationsOf(doc)).map((dangling) => ({
     rule: "dangling-figure-reference",
     severity: "warning",
     line: 0,

package/src/detectors/definition-use.ts

@@ -0,0 +1,41 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText } from "../structure/definition-use.ts";
+import { expansionConflicts, expansionsIn } from "../acronym-expansions.ts";
+import { linesOf, lineNumberAt } from "../structure/lines.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const bodyOf = (doc: ProseDocument): BodyText[] => doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
+
+const findingAt = (doc: ProseDocument, offset: number, values: Readonly<Record<string, string | number>>): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, offset),
+  values: { ...values, offset },
+});
+
+/** 定義したのに、定義の外で一度も使っていない語。 */
+export const unusedDefinition: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : unusedDefinitions(definedTerms(doc.structure), bodyOf(doc)).map((defined) => findingAt(doc, defined.span.start, { term: defined.term }));
+
+/** 文の途中で括弧に入れて定義した語を、定義より前で使っている所。 */
+export const useBeforeDefinition: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc)).map((use) => findingAt(doc, use.offset, { term: use.term.term, defined: use.term.line }));
+
+/** 同じ略語を、文書の中で二通りに展開している所。 */
+export const acronymExpansionConflict: Detector = (doc): Finding[] => {
+  const lines = linesOf(doc.source);
+  return expansionConflicts(bodyOf(doc).flatMap(expansionsIn)).map(({ expansion, first }) =>
+    findingAt(doc, expansion.offset, {
+      acronym: expansion.acronym,
+      name: expansion.name,
+      first: first.name,
+      firstLine: lineNumberAt(lines, first.offset) ?? 0,
+    }),
+  );
+};

package/src/detectors/doubled-punctuation.ts

@@ -3,7 +3,7 @@ import { quoteAround } from "./quote-around.ts";
 
 /**
  * 句読点が二つ並んだところ（「。。」「、。」「,,」「..」）。打ち直しで残った印。
- * 同じ印を三つ以上並べたもの（「...」「。。。」）は、わざと伸ばした書き方なので数えない。
+ * 同じ印を三つ以上並べたもの（「...」「。。。」）は、わざと伸ばした書き方なので数えない。その後ろに一つだけ付けた印（「...。」）も数えない。
  * コロンは「::」（C++ の名前、IPv6）があるので見ない。
  */
 const PUNCTUATION_RUN = /[、。，．,.;；]{2,}/gu;
@@ -18,6 +18,9 @@ const JOINED = /[\p{L}\p{N}/]/u;
 
 const isDrawnOut = (run: string): boolean => run.length >= 3 && [...run].every((mark) => mark === run.charAt(0));
 
+/** 伸ばした印（「...」「、、、」）は三点リーダーの代わりで、すぐ後ろの一つの印（「...。」「、、、。」）は文を閉じる印。 */
+const isDrawnOutThenClosed = (run: string): boolean => isDrawnOut(run.slice(0, -1));
+
 const isJoinedDots = (text: string, start: number, run: string): boolean =>
   run === ".." && (JOINED.test(text.charAt(start + run.length)) || text.charAt(start - 1) === "/");
 
@@ -30,7 +33,7 @@ const withoutWordDot = (text: string, found: DoubledMarks): DoubledMarks =>
     : found;
 
 const isSlip = (text: string, { start, run }: DoubledMarks): boolean =>
-  run.length >= 2 && !isDrawnOut(run) && !AFTER_ABBREVIATION.test(run) && !isJoinedDots(text, start, run);
+  run.length >= 2 && !isDrawnOut(run) && !isDrawnOutThenClosed(run) && !AFTER_ABBREVIATION.test(run) && !isJoinedDots(text, start, run);
 
 /** text の中の、句読点が重なった並び（位置と並び）。 */
 export const doubledMarks = (text: string): DoubledMarks[] =>