chaffjs 0.20.0 → 0.22.0

package/src/commands/plugin-init.ts

@@ -0,0 +1,150 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { API_VERSION } from "../api.ts";
+import { VERSION } from "../version.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+// chaff init --plugin <name>: a rule pack to start from, written in YAML alone. One rule, its word list in Japanese and
+// English, and a test command (chaff plugin-test) that checks each rule's example against the rule.
+
+/** A pack's own name: lowercase letters, digits and hyphens, optionally under a scope (@team/house). */
+const PACK_NAME = /^(?:(@[a-z0-9][a-z0-9._-]*)\/)?([a-z][a-z0-9-]*)$/u;
+
+export type PackName = { readonly scope: string | undefined; readonly name: string };
+
+/** The name as written after --plugin, or undefined when it cannot be a plugin's name. "chaff-plugin-" in front is allowed and dropped. */
+export const packNameOf = (written: string | undefined): PackName | undefined => {
+  const match = PACK_NAME.exec((written ?? "").replace(/(^|\/)chaff-plugin-/u, "$1"));
+  if (match === null) return undefined;
+  const [, scope, name] = match;
+  return name === undefined ? undefined : { scope, name };
+};
+
+/** The package's name and the folder it is made in: chaff-plugin-house, or @team/chaff-plugin-house in chaff-plugin-house. */
+export const packageOf = (pack: PackName): { readonly packageName: string; readonly folder: string } => ({
+  packageName: pack.scope === undefined ? `chaff-plugin-${pack.name}` : `${pack.scope}/chaff-plugin-${pack.name}`,
+  folder: `chaff-plugin-${pack.name}`,
+});
+
+const RULE = `# One rule of the pack. It is written as a rule under custom_rules in chaff.yaml is; see
+# https://isamu.github.io/lab/en/guide/adding-rules for every field.
+id: avoid-words
+type: words
+# The words come from lexicons/<language>/avoid-words.yaml, in the document's language.
+word_list: avoid-words
+name: { ja: チームで使わない言葉, en: A word the team does not use }
+why:
+  ja: このチームでは、同じものを決まった言葉で呼びます。別の言葉が混ざると、読む人は別のものかと迷います。
+  en: The team calls each thing by one word. Another word makes a reader wonder whether it is another thing.
+how_to_fix: { ja: チームの言葉に置き換えます。, en: Use the team's word. }
+message:
+  ja: 「{matched}」ではなく「{preferred}」と書きます
+  en: 'Write "{preferred}", not "{matched}"'
+level: warning
+example:
+  ja: { before: 弊社の新しい窓口をご案内します。, after: 当社の新しい窓口をご案内します。 }
+  en: { before: We utilize the new form for every request., after: We use the new form for every request. }
+rewrite:
+  depth: light
+  ja:
+    direction: 指された言葉だけを、チームの言葉に置き換えます。
+    pairs:
+      - { before: 弊社の新しい窓口をご案内します。, after: 当社の新しい窓口をご案内します。 }
+      - { before: 弊社では毎月点検しています。, after: 当社では毎月点検しています。 }
+    keep: [文のほかの部分]
+    avoid: [言葉と一緒に文の意味を変える]
+  en:
+    direction: Replace only the flagged word with the team's word.
+    pairs:
+      - { before: We utilize the new form for every request., after: We use the new form for every request. }
+      - { before: Utilize the search box first., after: Use the search box first. }
+    keep: [the rest of the sentence]
+    avoid: [changing what the sentence says along with the word]
+`;
+
+const LEXICON_JA = `# 使わない言葉（pattern）と、使う言葉（rewrite）。
+- { pattern: 弊社, rewrite: 当社 }
+`;
+
+const LEXICON_EN = `# The word not to use (pattern) and the word to use (rewrite).
+- { pattern: utilize, rewrite: use }
+`;
+
+const packageJson = (packageName: string): string =>
+  `${JSON.stringify(
+    {
+      name: packageName,
+      version: "0.1.0",
+      description: "Rules for chaff, written in YAML.",
+      files: ["rules", "lexicons", "styles"],
+      chaff: { apiVersion: API_VERSION },
+      scripts: { test: "chaffjs plugin-test ." },
+      peerDependencies: { chaffjs: `>=${VERSION}` },
+    },
+    null,
+    2,
+  )}\n`;
+
+const FILES = (packageName: string): Readonly<Record<string, string>> => ({
+  "package.json": packageJson(packageName),
+  "rules/avoid-words.yaml": RULE,
+  "lexicons/ja/avoid-words.yaml": LEXICON_JA,
+  "lexicons/en/avoid-words.yaml": LEXICON_EN,
+});
+
+const TEXT: Texts<{
+  readonly badName: (written: string) => string;
+  readonly exists: (folder: string) => string;
+  readonly made: (folder: string, packageName: string) => string;
+  readonly next: (folder: string, name: string) => readonly string[];
+}> = {
+  ja: {
+    badName: (written) => `--plugin ${written}: プラグインの名前は英小文字・数字・ハイフンで書きます（house、@team/house）`,
+    exists: (folder) => `${folder} はもうあります。上書きしないので、別の名前にするか消してから実行してください`,
+    made: (folder, packageName) => `${folder}/ に YAML だけのルールの束 ${packageName} を作りました。`,
+    next: (folder, name) => [
+      "",
+      "次に:",
+      `  cd ${folder} && npx chaffjs plugin-test .    ルールの例をルールにかけて確かめる`,
+      `  chaff.yaml に plugins: [./${folder}] と書くと、${name}/avoid-words として動きます`,
+      "",
+    ],
+  },
+  en: {
+    badName: (written) => `--plugin ${written}: a plugin's name is lowercase letters, digits and hyphens (house, @team/house)`,
+    exists: (folder) => `${folder} already exists. Nothing is overwritten; choose another name or remove it first`,
+    made: (folder, packageName) => `Made the YAML rule pack ${packageName} in ${folder}/.`,
+    next: (folder, name) => [
+      "",
+      "Next:",
+      `  cd ${folder} && npx chaffjs plugin-test .    check each rule against its own example`,
+      `  add plugins: [./${folder}] to chaff.yaml and it runs as ${name}/avoid-words`,
+      "",
+    ],
+  },
+};
+
+/** Makes the pack in dir. Lines to print, and whether it was made; nothing is written when the folder is already there. */
+export const initPlugin = (dir: string, written: string | undefined, ui: UiLanguage): { readonly ok: boolean; readonly lines: readonly string[] } => {
+  const text = TEXT[ui];
+  const pack = packNameOf(written);
+  if (pack === undefined) return { ok: false, lines: [text.badName(written ?? "")] };
+  const { packageName, folder } = packageOf(pack);
+  if (existsSync(join(dir, folder))) return { ok: false, lines: [text.exists(folder)] };
+  Object.entries(FILES(packageName)).forEach(([path, body]) => {
+    mkdirSync(dirname(join(dir, folder, path)), { recursive: true });
+    writeFileSync(join(dir, folder, path), body, "utf8");
+  });
+  const name = pack.scope === undefined ? pack.name : `${pack.scope}/${pack.name}`;
+  return {
+    ok: true,
+    lines: [text.made(folder, packageName), ...Object.keys(FILES(packageName)).map((path) => `  ${folder}/${path}`), ...text.next(folder, name)],
+  };
+};
+
+/** chaff init --plugin <name>: makes the pack in dir and says what it made, or why it did not. */
+export const runInitPlugin = (dir: string, written: string | undefined, ui: UiLanguage): number => {
+  const made = initPlugin(dir, written, ui);
+  made.lines.forEach((line) => (made.ok ? console.log(line) : console.error(line)));
+  return made.ok ? 0 : 1;
+};

package/src/commands/plugin-test.ts

@@ -0,0 +1,111 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { EMPTY, type Config } from "../config/load.ts";
+import { withExtensions } from "../extension/load.ts";
+import { extensionProblems } from "../extension/problem-text.ts";
+import { loadGenres } from "../genre-load.ts";
+import type { RuleDefinition } from "../plugin.ts";
+import type { Skipped } from "../run.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+import type { Checked } from "./feedback.ts";
+
+// chaff plugin-test [folder]: loads a plugin as chaff.yaml would, then runs each of its rules on the rule's own example,
+// in every language the example is written in. The before must give the rule a finding and the after must give it
+// none. A rule that does not run there (no word list for the language) fails, with the reason.
+
+export type PluginTestContext = {
+  readonly ui: UiLanguage;
+  /** Lints one file with these settings, as chaff on the command line does. */
+  readonly check: (path: string, config: Config, argv: readonly string[]) => Promise<Pick<Checked, "findings" | "skipped">>;
+};
+
+type Outcome = { readonly rule: string; readonly language: string; readonly failure: string | undefined };
+
+const TEXT: Texts<{
+  readonly noRules: (dir: string) => string;
+  readonly beforeQuiet: string;
+  readonly afterFlagged: (count: number) => string;
+  readonly notRun: (why: string) => string;
+  readonly noExample: string;
+  readonly summary: (passed: number, total: number) => string;
+}> = {
+  ja: {
+    noRules: (dir) => `${dir} にルールがありません。`,
+    beforeQuiet: "例の before で指摘が出ません",
+    afterFlagged: (count) => `例の after で指摘が ${String(count)} 件出ます`,
+    notRun: (why) => `動きません（${why}）`,
+    noExample: "例がありません",
+    summary: (passed, total) => `${String(total)} 件のうち ${String(passed)} 件が通りました。`,
+  },
+  en: {
+    noRules: (dir) => `${dir} has no rules.`,
+    beforeQuiet: "the example's before gets no finding",
+    afterFlagged: (count) => `the example's after gets ${String(count)} ${count === 1 ? "finding" : "findings"}`,
+    notRun: (why) => `it does not run (${why})`,
+    noExample: "it has no example",
+    summary: (passed, total) => `${String(passed)} of ${String(total)} passed.`,
+  },
+};
+
+/** The first genre the rule is for: the example runs where the rule does. */
+const genreFor = (rule: RuleDefinition): string => {
+  const genres = loadGenres().genres.map((genre) => genre.id);
+  return genres.find((genre) => rule.use_for.some((target) => genre === target || genre.startsWith(`${target}/`))) ?? genres[0] ?? "business/report";
+};
+
+const skippedWhy = (skipped: readonly Skipped[], rule: string): string | undefined => skipped.find((entry) => entry.rule === rule)?.why;
+
+/** One rule in one language: before flagged, after clean. */
+const testExample = async (rule: RuleDefinition, language: string, config: Config, context: PluginTestContext): Promise<Outcome> => {
+  const text = TEXT[context.ui];
+  const example = rule.guide?.examples[language];
+  if (example === undefined) return { rule: rule.id, language, failure: text.noExample };
+  const dir = mkdtempSync(join(tmpdir(), "chaff-plugin-test-"));
+  const argv = ["--language", language, "--genre", genreFor(rule)];
+  const run = async (name: string, body: string): Promise<Pick<Checked, "findings" | "skipped">> => {
+    writeFileSync(join(dir, name), `${body.trimEnd()}\n`, "utf8");
+    return context.check(join(dir, name), config, argv);
+  };
+  const before = await run("before.md", example.before);
+  const why = skippedWhy(before.skipped, rule.id);
+  if (why !== undefined) return { rule: rule.id, language, failure: text.notRun(why) };
+  if (!before.findings.some((finding) => finding.rule === rule.id)) return { rule: rule.id, language, failure: text.beforeQuiet };
+  const after = (await run("after.md", example.after)).findings.filter((finding) => finding.rule === rule.id).length;
+  return { rule: rule.id, language, failure: after === 0 ? undefined : text.afterFlagged(after) };
+};
+
+const lineOf = (outcome: Outcome): string =>
+  outcome.failure === undefined ? `  ✓ ${outcome.rule} (${outcome.language})` : `  ✗ ${outcome.rule} (${outcome.language}): ${outcome.failure}`;
+
+/** The languages a rule's example is written in, or the rule's languages when it has none, so a missing example is said. */
+const languagesOf = (rule: RuleDefinition): readonly string[] => {
+  const written = Object.keys(rule.guide?.examples ?? {});
+  return written.length > 0 ? written : (rule.languages ?? ["ja", "en"]);
+};
+
+/** Exit 0 when every rule passes on every example; 1 when the plugin cannot be loaded or a rule fails. */
+export const runPluginTest = async (folder: string | undefined, context: PluginTestContext): Promise<number> => {
+  const text = TEXT[context.ui];
+  const dir = resolve(folder ?? ".");
+  const config = await withExtensions({ ...EMPTY, plugins: [dir], baseDir: dir, path: dir });
+  const problems = extensionProblems(config, context.ui);
+  if (problems.length > 0) {
+    problems.forEach((problem) => console.error(problem));
+    return 1;
+  }
+  const rules = config.extensions?.rules ?? [];
+  if (rules.length === 0) {
+    console.error(text.noRules(dir));
+    return 1;
+  }
+  const cases = rules.flatMap((rule) => languagesOf(rule).map((language) => ({ rule, language })));
+  const outcomes = await cases.reduce<Promise<Outcome[]>>(
+    async (done, entry) => [...(await done), await testExample(entry.rule, entry.language, config, context)],
+    Promise.resolve([]),
+  );
+  outcomes.map(lineOf).forEach((line) => console.log(line));
+  const passed = outcomes.filter((outcome) => outcome.failure === undefined).length;
+  console.log(`\n${text.summary(passed, outcomes.length)}`);
+  return passed === outcomes.length ? 0 : 1;
+};

package/src/config/load.ts

@@ -52,6 +52,8 @@ export type Config = {
   readonly customRules?: unknown;
   /** grade as written: the rubric `chaff grade` reads (grade/rubric.ts). */
   readonly grade?: unknown;
+  /** fix_plan as written: the depth chaff fix-plan rewrites to (fix-plan/chosen-depth.ts reads and checks it). */
+  readonly fixPlan?: unknown;
   /** plugins as written: package names and paths. extension/plugin-load.ts reads and checks them. */
   readonly plugins?: unknown;
   /** The code chaff.yaml names, once loaded (extension/load.ts). Reading chaff.yaml does not load it. */
@@ -197,6 +199,7 @@ export const loadConfig = (path: string): Config => {
     style: raw["style"] === undefined || raw["style"] === null ? undefined : (str(raw["style"]) ?? printed(raw["style"])),
     customRules: raw["custom_rules"],
     grade: raw["grade"],
+    fixPlan: raw["fix_plan"],
     plugins: raw["plugins"],
   };
 };

package/src/config/option-problems.ts

@@ -36,7 +36,7 @@ const TEXT: Texts<ProblemText> = {
   ja: {
     notAMap: (where, value) => `${where}: options の ${value} は読めません。ルールの名前の下に、オプションの名前と値を並べてください`,
     problem: (where, problem) => {
-      if (problem.kind === "unknown-rule") return `${where}: options の ${problem.rule} というルールはありません（npx chaff rules --json で一覧が出ます）`;
+      if (problem.kind === "unknown-rule") return `${where}: options の ${problem.rule} というルールはありません（npx chaffjs rules --json で一覧が出ます）`;
       if (problem.kind === "no-options") return `${where}: ${problem.rule} にはオプションがありません。options に書いても何も変わりません`;
       if (problem.kind === "not-a-map") return `${where}: options の ${problem.rule} の下には、オプションの名前と値を並べてください`;
       if (problem.kind === "unknown-option")
@@ -47,7 +47,7 @@ const TEXT: Texts<ProblemText> = {
   en: {
     notAMap: (where, value) => `${where}: cannot read ${value} under options. Under each rule's name, list option names and values`,
     problem: (where, problem) => {
-      if (problem.kind === "unknown-rule") return `${where}: there is no rule named ${problem.rule} under options (npx chaff rules --json lists them)`;
+      if (problem.kind === "unknown-rule") return `${where}: there is no rule named ${problem.rule} under options (npx chaffjs rules --json lists them)`;
       if (problem.kind === "no-options") return `${where}: ${problem.rule} takes no options, so writing some changes nothing`;
       if (problem.kind === "not-a-map") return `${where}: under options, ${problem.rule} needs option names and values`;
       if (problem.kind === "unknown-option") return `${where}: ${problem.rule} has no option ${problem.option} (it takes ${problem.known.join(" / ")})`;

package/src/config/rule-problems.ts

@@ -9,7 +9,7 @@ const TEXT: Texts<{
   readonly numberOnSeverity: (where: string, id: string) => string;
 }> = {
   ja: {
-    unknown: (where, id) => `${where}: ${id} というルールはありません（npx chaff rules --json で一覧が出ます）`,
+    unknown: (where, id) => `${where}: ${id} というルールはありません（npx chaffjs rules --json で一覧が出ます）`,
     unreadable: (where, id, value) => `${where}: ${id} の値 ${value} は読めません（strict / normal / relaxed / off か、正の数）`,
     numberOnSemantic: (where, id) =>
       `${where}: ${id} は意味を読む検査なので数値の上限はありません。normal として動きます（strict / normal / relaxed / off で書いてください）`,
@@ -17,7 +17,7 @@ const TEXT: Texts<{
       `${where}: ${id} には数の上限がありません。normal として動きます（段階は指摘の重さを変えます。relaxed で一段軽く、off で止まります）`,
   },
   en: {
-    unknown: (where, id) => `${where}: there is no rule named ${id} (npx chaff rules --json lists them)`,
+    unknown: (where, id) => `${where}: there is no rule named ${id} (npx chaffjs rules --json lists them)`,
     unreadable: (where, id, value) => `${where}: cannot read ${value} as the level of ${id} (strict / normal / relaxed / off, or a positive number)`,
     numberOnSemantic: (where, id) => `${where}: ${id} reads meaning and has no numeric limit; it runs as normal (write strict / normal / relaxed / off)`,
     numberOnSeverity: (where, id) =>

package/src/custom/checked.ts

@@ -0,0 +1,8 @@
+import type { CustomProblem } from "./parse.ts";
+
+/** One field of one rule, read: its value when it can be used, and what is wrong with it otherwise. */
+export type Checked<T> = { readonly value: T | undefined; readonly problems: readonly CustomProblem[] };
+
+export const ok = <T>(value: T): Checked<T> => ({ value, problems: [] });
+
+export const failed = <T>(...problems: CustomProblem[]): Checked<T> => ({ value: undefined, problems });

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,
   });