chaffjs 0.15.0 → 0.16.0

package/src/commands/test.ts

@@ -7,20 +7,80 @@ import { buildDocument, teamRules } from "../document.ts";
 import { guessLanguage } from "../detect.ts";
 import { collectTargets } from "../files.ts";
 import { loadRules } from "../rule-load.ts";
+import { counted } from "../render/plural.ts";
 import { CHECKS_FILE, loadChecks, type UserCheck } from "../checks.ts";
-import { CACHE_DIR, credentialHint, describeFailure, hasCredentials } from "../judge.ts";
+import { CACHE_DIR, credentialHint, describeFailure, hasCredentials, type JudgeOptions } from "../judge.ts";
 import { ENV_FILE, loadEnvFile } from "../env.ts";
 import { planSemantic, runSemantic } from "../run-semantic.ts";
-import { MACHINE_BANNER, renderPlan, renderSemantic } from "../render/semantic.ts";
+import { machineBanner, renderPlan, renderSemantic } from "../render/semantic.ts";
 import type { Config } from "../config/load.ts";
 import type { Finding, RuleDefinition } from "../plugin.ts";
-import type { Failure } from "../backends/types.ts";
+import type { BackendName, Failure } from "../backends/types.ts";
 import { profileFor } from "../profile/for-file.ts";
+import { CLI_TEXT } from "../cli-text.ts";
+import { sharedLanguage, type Texts, type UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{
+  readonly total: (total: number) => string;
+  readonly sentTo: (backend: string, model: string, found: boolean) => string;
+  readonly envRead: (path: string) => string;
+  readonly envWhere: (found: string | undefined) => string;
+  readonly notRun: (why: string, what: string, where: string) => readonly string[];
+  readonly noCredentials: (backend: BackendName) => string;
+  readonly refused: (backend: BackendName, status: string) => string;
+  readonly checkKey: string;
+  readonly quota: (backend: BackendName, status: string) => string;
+  readonly returned: (backend: BackendName, status: string) => string;
+  readonly noCause: string;
+  readonly tally: (machine: number, ai: number) => string;
+  readonly untouched: string;
+}> = {
+  ja: {
+    total: (total) => `  合計 ${total} 箇所を送ります。--dry-run なので API は呼んでいません。`,
+    sentTo: (backend, model, found) => `  送り先: ${backend} / ${model}（認証${found ? "あり" : "なし"}）`,
+    envRead: (path) => `  ${path} を読みました。`,
+    envWhere: (found) => (found === undefined ? `${ENV_FILE} に書いても読みます（いまは ${ENV_FILE} がありません）` : `${found} は読みました`),
+    notRun: (why, what, where) => [`  意味を読む検査は動かしていません。${why}`, `  ${what}`, `  ${where}。`, "  機械による判定はすべて動いています。"],
+    noCredentials: (backend) => `${backend} の認証情報がありません。`,
+    refused: (backend, status) => `${backend} が鍵を受け付けませんでした（${status}）。`,
+    checkKey: "鍵が正しいか、その provider のものかを確かめてください。",
+    quota: (backend, status) => `${backend} の残高か上限に達しました（${status}）。`,
+    returned: (backend, status) => `${backend} が ${status} を返しました。`,
+    noCause: "原因は返ってきませんでした",
+    tally: (machine, ai) => `  機械 ${machine} 件 / AI ${ai} 件`,
+    untouched: "  文章は書き換えていません。直すのは書いた人です。",
+  },
+  en: {
+    total: (total) => `  ${counted(total, "passage")} in all would be sent. With --dry-run the API was not called.`,
+    sentTo: (backend, model, found) => `  Sent to: ${backend} / ${model} (${found ? "credentials found" : "no credentials"})`,
+    envRead: (path) => `  Read ${path}.`,
+    envWhere: (found) => (found === undefined ? `A key written in ${ENV_FILE} is read too (there is no ${ENV_FILE} now)` : `${found} was read`),
+    notRun: (why, what, where) => [`  The checks that read meaning did not run. ${why}`, `  ${what}`, `  ${where}.`, "  Every machine check ran."],
+    noCredentials: (backend) => `There are no credentials for ${backend}.`,
+    refused: (backend, status) => `${backend} did not accept the key (${status}).`,
+    checkKey: "Check that the key is right and that it is for that provider.",
+    quota: (backend, status) => `${backend} has run out of balance or hit a limit (${status}).`,
+    returned: (backend, status) => `${backend} returned ${status}.`,
+    noCause: "No reason was given.",
+    tally: (machine, ai) => `  ${machine} by machine / ${ai} by AI`,
+    untouched: "  The text was not changed. Fixing it is the writer's job.",
+  },
+};
+
+const DIVIDER = "─".repeat(60);
 
 export type TestContext = {
   readonly config: Config;
   readonly resolveGenre: (path: string, source: string, config: Config) => { genre: string; from: string };
-  readonly inspect: (path: string, config: Config, argv: readonly string[]) => Promise<{ text: string; outcome: { findings: readonly Finding[] } }>;
+  readonly inspect: (
+    path: string,
+    config: Config,
+    argv: readonly string[],
+  ) => Promise<{ text: string; language: string; outcome: { findings: readonly Finding[] } }>;
+  /** The language of what is not about the documents: chaff.yaml's language, else the locale. */
+  readonly ui: UiLanguage;
+  /** The judges to call instead of the providers' own clients. Tests pass stand-ins; the command line never does. */
+  readonly clients?: Pick<JudgeOptions, "anthropicClient" | "openaiClient">;
 };
 
 type Judged = { path: string; outcome: Awaited<ReturnType<typeof runSemantic>>; rules: RuleDefinition[]; language: string };
@@ -37,8 +97,8 @@ const judgeAll = async (
       const source = plainSource(await readFile(path, "utf8"));
       const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
       const adapter = await loadAdapter(language);
-      const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language));
       const { genre } = resolveGenre(path, source, config);
+      const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language, genre));
       const rules = loadRules(language);
       return { path, outcome: await runSemantic(doc, rules, checks, config.rules, genre, options), rules, language };
     }),
@@ -50,43 +110,51 @@ const dryRun = async (
   config: Config,
   checks: readonly UserCheck[],
   resolveGenre: TestContext["resolveGenre"],
-  envFile: string | undefined,
+  closing: { readonly envFile: string | undefined; readonly language: UiLanguage },
 ): Promise<void> => {
   const plans = await Promise.all(
     paths.map(async (path) => {
       const source = plainSource(await readFile(path, "utf8"));
       const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
       const adapter = await loadAdapter(language);
-      const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language));
       const { genre } = resolveGenre(path, source, config);
-      return { path, jobs: planSemantic(doc, loadRules(language), checks, config.rules, genre), sentences: doc.sentences.length };
+      const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language, genre));
+      return { path, jobs: planSemantic(doc, loadRules(language), checks, config.rules, genre), sentences: doc.sentences.length, language };
     }),
   );
-  plans.forEach(({ path, jobs, sentences }) => console.log(renderPlan(path, jobs, sentences).join("\n")));
+  plans.forEach(({ path, jobs, sentences, language }) => console.log(renderPlan(path, jobs, sentences, language).join("\n")));
   const total = plans.reduce((sum, plan) => sum + plan.jobs.reduce((count, job) => count + job.candidates.length, 0), 0);
-  const from = envFile === undefined ? "" : `  ${envFile} を読みました。`;
-  const where = `${config.aiBackend} / ${config.aiModel}（認証${hasCredentials(config.aiBackend) ? "あり" : "なし"}）`;
-  console.log(
-    [
-      "",
-      "─".repeat(60),
-      "",
-      `  合計 ${total} 箇所を送ります。--dry-run なので API は呼んでいません。`,
-      `  送り先: ${where}`,
-      ...(from === "" ? [] : [from]),
-      "",
-    ].join("\n"),
-  );
+  const text = TEXT[closing.language];
+  const from = closing.envFile === undefined ? [] : [text.envRead(closing.envFile)];
+  console.log(["", DIVIDER, "", text.total(total), text.sentTo(config.aiBackend, config.aiModel, hasCredentials(config.aiBackend)), ...from, ""].join("\n"));
+};
+
+/**
+ * API が返した失敗を人の言葉にする。生のスタックトレースを人に見せない。
+ * 鍵はあるのに弾かれたときに「ありません」と言うと、設定済みの鍵をもう一度設定しに行かせる。
+ * 残高切れも同じで、「鍵を確かめてください」と言われても鍵は正しい。
+ */
+const whyFailed = (failure: Failure, backend: BackendName, language: UiLanguage): { why: string; what: string } => {
+  const text = TEXT[language];
+  const status = String(failure.status ?? "?");
+  if (failure.kind === "auth") return { why: text.refused(backend, status), what: text.checkKey };
+  const what = failure.message ?? text.noCause;
+  return failure.kind === "quota" ? { why: text.quota(backend, status), what } : { why: text.returned(backend, status), what };
 };
 
+/** Why the checks that read meaning did not run, and where a key would be read from. */
+const notRunNotice = (why: string, what: string, envFile: string | undefined, language: UiLanguage): string =>
+  ["", ...TEXT[language].notRun(why, what, TEXT[language].envWhere(envFile)), ""].join("\n");
+
 /**
  * 機械と AI を見出しで分けて出す。読む人が「これは揺れる判定か」を知らないと、
  * AI の誤検知に振り回される。workflow spec §7、samples/README の軸 2。
+ * 見出しと指摘は文書の言語、締めは文書がそろっていればその言語、混ざっていれば ui の言語。
  */
 export const runTest = async (targets: readonly string[], argv: readonly string[], context: TestContext): Promise<number> => {
   const paths = collectTargets(targets.length > 0 ? targets : ["."]);
   if (paths.length === 0) {
-    console.error(`Markdown が 1 つも見つかりませんでした: ${targets.join(", ")}`);
+    console.error(CLI_TEXT[context.ui].noMarkdown(targets.join(", ")));
     return 1;
   }
   const { config, resolveGenre, inspect } = context;
@@ -95,31 +163,20 @@ export const runTest = async (targets: readonly string[], argv: readonly string[
   const checks = loadChecks(join(process.cwd(), CHECKS_FILE));
   const results = await Promise.all(paths.map((path) => inspect(path, config, argv)));
   results.forEach((result) => {
-    console.log(result.text.replace(/\n/u, `\n${MACHINE_BANNER.join("\n")}`));
+    console.log(result.text.replace(/\n/u, `\n${machineBanner(result.language).join("\n")}`));
   });
+  const closing = sharedLanguage(
+    results.map((result) => result.language),
+    context.ui,
+  );
   const machineOnly = results.some((result) => result.outcome.findings.some((finding) => finding.severity === "error")) ? 1 : 0;
-  const where = envFile === undefined ? `${ENV_FILE} に書いても読みます（いまは ${ENV_FILE} がありません）` : `${envFile} は読みました`;
-  const notRun = (why: string, what: string): string =>
-    ["", `  意味を読む検査は動かしていません。${why}`, `  ${what}`, `  ${where}。`, "  機械による判定はすべて動いています。", ""].join("\n");
-  const noCredentials = notRun(`${config.aiBackend} の認証情報がありません。`, credentialHint(config.aiBackend));
-  /**
-   * API が返した失敗を人の言葉にする。生のスタックトレースを人に見せない。
-   * 鍵はあるのに弾かれたときに「ありません」と言うと、設定済みの鍵をもう一度設定しに行かせる。
-   * 残高切れも同じで、「鍵を確かめてください」と言われても鍵は正しい。
-   */
-  const failed = (failure: Failure): string => {
-    if (failure.kind === "auth")
-      return notRun(`${config.aiBackend} が鍵を受け付けませんでした（${failure.status ?? "?"}）。`, "鍵が正しいか、その provider のものかを確かめてください。");
-    if (failure.kind === "quota") return notRun(`${config.aiBackend} の残高か上限に達しました（${failure.status ?? "?"}）。`, failure.message);
-    return notRun(`${config.aiBackend} が ${failure.status ?? "?"} を返しました。`, failure.message);
-  };
   if (argv.includes("--dry-run")) {
-    await dryRun(paths, config, checks, resolveGenre, envFile);
+    await dryRun(paths, config, checks, resolveGenre, { envFile, language: closing });
     return machineOnly;
   }
   // 呼んでから落ちるのを待たない。認証が無いときの SDK の例外は型で判別できない。
   if (!hasCredentials(config.aiBackend)) {
-    console.log(noCredentials);
+    console.log(notRunNotice(TEXT[closing].noCredentials(config.aiBackend), credentialHint(config.aiBackend, closing), envFile, closing));
     return machineOnly;
   }
   const options = {
@@ -127,12 +184,14 @@ export const runTest = async (targets: readonly string[], argv: readonly string[
     backend: config.aiBackend,
     cacheDir: join(process.cwd(), CACHE_DIR),
     confidenceThreshold: config.confidenceThreshold,
+    ...context.clients,
   };
   const semantic = await judgeAll(paths, config, checks, options, resolveGenre).catch((error: unknown) => {
     // API が返した失敗だけを受け止める。ネットワーク断やコードの誤りは握りつぶさない。
     const failure = describeFailure(config.aiBackend, error);
     if (failure === undefined) throw error;
-    console.log(failed(failure));
+    const { why, what } = whyFailed(failure, config.aiBackend, closing);
+    console.log(notRunNotice(why, what, envFile, closing));
     return undefined;
   });
   if (semantic === undefined) return machineOnly;
@@ -142,8 +201,6 @@ export const runTest = async (targets: readonly string[], argv: readonly string[
   });
   const machine = results.flatMap((result) => result.outcome.findings);
   const ai = semantic.flatMap((entry) => entry.outcome.findings);
-  console.log(
-    ["", "─".repeat(60), "", `  機械 ${machine.length} 件 / AI ${ai.length} 件`, "  文章は書き換えていません。直すのは書いた人です。", ""].join("\n"),
-  );
+  console.log(["", DIVIDER, "", TEXT[closing].tally(machine.length, ai.length), TEXT[closing].untouched, ""].join("\n"));
   return [...machine, ...ai].some((finding) => finding.severity === "error") ? 1 : 0;
 };

package/src/commands/tree.ts

@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import { loadAdapter } from "../adapter-load.ts";
 import { applyByPath } from "../config/by-path.ts";
 import { profileFor } from "../profile/for-file.ts";
+import { resolveGenre } from "../resolve-genre.ts";
 import { guessLanguage } from "../detect.ts";
 import { isMarkdownPath } from "../structure/markdown-path.ts";
 import { buildStructure } from "../structure/of.ts";
@@ -35,15 +36,15 @@ const TEXT: Texts<{
   },
 };
 
-export const treeText = (context: TreeContext): (typeof TEXT)["ja"] => TEXT[context.ui ?? "ja"];
+const treeText = (context: TreeContext): (typeof TEXT)["ja"] => TEXT[context.ui ?? "ja"];
 
-const FORMATS = ["sexp", "json"];
+const FORMATS: ReadonlySet<string> = new Set(["sexp", "json"]);
 
 /** 値を取るフラグ。その次の引数は値で、対象のファイルではない。 */
-const VALUED = ["--format", "--language"];
+const VALUED: ReadonlySet<string> = new Set(["--format", "--language", "--genre"]);
 
 export const treeTargets = (argv: readonly string[]): string[] =>
-  argv.slice(1).filter((arg, index, all) => !arg.startsWith("--") && !VALUED.includes(all[index - 1] ?? ""));
+  argv.slice(1).filter((arg, index, all) => !arg.startsWith("--") && !VALUED.has(all[index - 1] ?? ""));
 
 export const readSource = async (path: string, context: TreeContext): Promise<string | undefined> => {
   try {
@@ -81,7 +82,7 @@ export const readTree = async (path: string, argv: readonly string[], context: T
   }
   // 日本語は形態素で数量と日付を読む。解析器が無ければ単位の表で読むので、木は作れる。
   await adapter.prepare?.({ pos: true });
-  const profile = profileFor(context.config, path, source, language);
+  const profile = profileFor(context.config, path, source, language, resolveGenre(path, source, context.config, context.flag(argv, "--genre")).genre);
   return { source, tree: buildStructure({ path, source, language, markdown: isMarkdownPath(path), profile }, adapter.structure) };
 };
 
@@ -108,7 +109,7 @@ export const inOrder = async (paths: readonly string[], each: (path: string) =>
  */
 export const runTree = async (paths: readonly string[], argv: readonly string[], context: TreeContext): Promise<number> => {
   const format = context.flag(argv, "--format") ?? "sexp";
-  if (paths.length === 0 || !FORMATS.includes(format)) {
+  if (paths.length === 0 || !FORMATS.has(format)) {
     console.error(treeText(context).usage);
     return 1;
   }

package/src/config/by-path.ts

@@ -44,12 +44,11 @@ export const matches = (glob: string, base: string, path: string): boolean => to
 type PathSettings = { genre?: string; language?: string; profile?: string };
 
 export const applyByPath = (rules: readonly PathRule[], base: string, path: string): PathSettings =>
-  rules.reduce<PathSettings>((acc, rule) => {
-    if (!rule.files.some((glob) => matches(glob, base, path))) return acc;
-    return {
-      ...acc,
-      ...(rule.genre === undefined ? {} : { genre: rule.genre }),
-      ...(rule.language === undefined ? {} : { language: rule.language }),
-      ...(rule.profile === undefined ? {} : { profile: rule.profile }),
-    };
-  }, {});
+  rules
+    .filter((rule) => rule.files.some((glob) => matches(glob, base, path)))
+    .reduce<PathSettings>((settings, rule) => {
+      if (rule.genre !== undefined) settings.genre = rule.genre;
+      if (rule.language !== undefined) settings.language = rule.language;
+      if (rule.profile !== undefined) settings.profile = rule.profile;
+      return settings;
+    }, {});

package/src/config/load.ts

@@ -30,6 +30,10 @@ export type Config = {
   readonly prefer: Readonly<Record<string, string>>;
   /** この種類の文書に無いと困る見出し。チームが自分で決める。 */
   readonly requiredSections: readonly string[];
+  /** チームの固有名詞（組織名・製品名）。1 つの名前として読み、漢字の連なりや繰り返しに数えない。 */
+  readonly names: readonly string[];
+  /** names に書かれていたが名前として読めなかった値。黙って捨てると、並べたつもりの名前が効いていないことに気づけない。 */
+  readonly unreadableNames: readonly string[];
   /** パスごとの上書き。設定ファイルのある場所からの相対で照合する。 */
   readonly byPath: readonly PathRule[];
   readonly baseDir: string;
@@ -54,6 +58,8 @@ export const EMPTY: Config = {
   jargon: [],
   prefer: {},
   requiredSections: [],
+  names: [],
+  unreadableNames: [],
   byPath: [],
   baseDir: process.cwd(),
 };
@@ -114,6 +120,21 @@ const preferOf = (raw: unknown): Record<string, string> =>
       )
     : {};
 
+const isNameEntry = (value: unknown): value is string | number => typeof value === "string" || typeof value === "number";
+
+const printed = (value: unknown): string => JSON.stringify(value) ?? String(value);
+
+/** 名前は文字列か数（2025 のような名前）の並び。並びでない値と、並びの中の名前でない項目は読めないものとして返す。 */
+const namesOf = (raw: unknown): { readonly names: string[]; readonly unreadable: string[] } => {
+  if (raw === undefined || raw === null) return { names: [], unreadable: [] };
+  if (!Array.isArray(raw)) return { names: [], unreadable: [printed(raw)] };
+  const entries: unknown[] = raw;
+  return {
+    names: wordsOf(entries.filter(isNameEntry)),
+    unreadable: entries.filter((entry) => !isNameEntry(entry)).map(printed),
+  };
+};
+
 const byPathOf = (raw: unknown): PathRule[] => (Array.isArray(raw) ? raw.map(toPathRule).filter((rule) => rule !== undefined) : []);
 
 /** 設定ファイルが無くても動く。あっても、既定から変えたものだけが書かれている。spec §18。 */
@@ -122,6 +143,7 @@ export const loadConfig = (path: string): Config => {
   if (!isRecord(raw)) return { ...EMPTY, path };
   const declared: unknown = raw["ai_backend"];
   const backend: BackendName = isBackend(declared) ? declared : DEFAULT_BACKEND;
+  const names = namesOf(raw["names"]);
   return {
     genre: str(raw["genre"]),
     profile: str(raw["profile"]),
@@ -137,6 +159,8 @@ export const loadConfig = (path: string): Config => {
     jargon: wordsOf(raw["jargon"]),
     prefer: preferOf(raw["prefer"]),
     requiredSections: wordsOf(raw["required_sections"]),
+    names: names.names,
+    unreadableNames: names.unreadable,
     byPath: byPathOf(raw["by_path"]),
     baseDir: dirname(path),
   };

package/src/config/name-problems.ts

@@ -0,0 +1,15 @@
+import type { Config } from "./load.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{ readonly unreadable: (where: string, value: string) => string }> = {
+  ja: {
+    unreadable: (where, value) => `${where}: names の ${value} は名前として読めません。names には名前を 1 行に 1 つずつ並べてください（- 個人情報保護委員会）`,
+  },
+  en: {
+    unreadable: (where, value) => `${where}: cannot read ${value} under names as a name. Write names as a list, one name per line (- Bank of England)`,
+  },
+};
+
+/** chaff.yaml の names のうち、名前として読めなかったもの。読めないまま黙ると、書いた人は名前を並べたつもりで何も変わっていない。 */
+export const nameProblems = (config: Pick<Config, "unreadableNames" | "path">, ui: UiLanguage = "ja"): string[] =>
+  config.unreadableNames.map((value) => TEXT[ui].unreadable(config.path ?? "chaff.yaml", value));

package/src/date-stamp.ts

@@ -21,7 +21,7 @@ const LABEL_EDGE = /[\s:：]/u;
 const datesOf = (candidate: StampCandidate): Span[] => candidate.dates.filter((date) => date.end > date.start);
 
 const withoutDates = (candidate: StampCandidate): string => {
-  const ordered = datesOf(candidate).sort((left, right) => left.start - right.start);
+  const ordered = datesOf(candidate).toSorted((left, right) => left.start - right.start);
   const gaps = ordered.reduce<{ readonly parts: readonly string[]; readonly from: number }>(
     (acc, date) => ({ parts: [...acc.parts, candidate.text.slice(acc.from, date.start)], from: Math.max(acc.from, date.end) }),
     { parts: [], from: 0 },

package/src/detectors/char-shape.ts

@@ -6,6 +6,9 @@ import { isAddressRun } from "./place-run.ts";
 import { isOneName } from "./name-run.ts";
 import { proseText } from "../measure.ts";
 import { parallelDotCount } from "./middle-dot.ts";
+import { maskSpans } from "../mask.ts";
+import { quotedSpans } from "../quoted-span.ts";
+import { nameSpans } from "../team-names.ts";
 
 /**
  * 文字の並びを見る検出。漢字の連なりが住所か名前かだけは、形態素解析の固有名詞と数で決める。
@@ -13,8 +16,8 @@ import { parallelDotCount } from "./middle-dot.ts";
  */
 const KANJI_RUN = /[一-鿿]+/gu;
 
-/** 漢字の連なりと、その文書全体の座標での範囲。 */
-type KanjiRun = { readonly text: string; readonly span: Span | undefined };
+/** 漢字の連なりと、その文書全体の座標での範囲。quoted は鉤括弧の中身がまるごとこの連なりであること。 */
+type KanjiRun = { readonly text: string; readonly span: Span | undefined; readonly quoted: boolean };
 
 const SPACE = /\s/gu;
 
@@ -22,14 +25,22 @@ const SPACE = /\s/gu;
  * 同じ連なりが文に二度出ても、それぞれの位置で読む。proseText は空白を詰めたり除いたりするだけなので、
  * 空白でない k 文字目は元の文でも空白でない k 文字目。番地の覆いは長さを保つので、proseText の位置がそのまま使える。
  */
-const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined): KanjiRun[] => {
+/** 番地と、チームが並べた名前を空白で覆う。名前は読み手が 1 語と知っているので、前後は別の連なりになる。 */
+const maskedProse = (prose: string, profile: DocumentProfile | undefined, names: readonly string[]): string =>
+  maskSpans(maskAddresses(prose, profile), nameSpans(prose, names));
+
+/** 鉤括弧の中身が、ちょうどこの範囲（文の先頭からの位置）か。括弧でくくった漢字だけの語は、書き手が 1 つの名前として示したもの。 */
+const fillsQuote = (sentence: Sentence, start: number, end: number): boolean =>
+  quotedSpans(sentence.text).some((span) => span.start === start && span.end === end);
+
+const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined, names: readonly string[]): KanjiRun[] => {
   const prose = proseText(sentence);
   const printed = compacted(sentence.text, "char").offsets;
-  return [...maskAddresses(prose, profile).matchAll(KANJI_RUN)].map((match) => {
+  return [...maskedProse(prose, profile, names).matchAll(KANJI_RUN)].map((match) => {
     const before = prose.slice(0, match.index).replace(SPACE, "").length;
     const [start, last] = [printed[before], printed[before + match[0].length - 1]];
-    const span = start === undefined || last === undefined ? undefined : { start: sentence.span.start + start, end: sentence.span.start + last + 1 };
-    return { text: match[0], span };
+    if (start === undefined || last === undefined) return { text: match[0], span: undefined, quoted: false };
+    return { text: match[0], span: { start: sentence.span.start + start, end: sentence.span.start + last + 1 }, quoted: fillsQuote(sentence, start, last + 1) };
   });
 };
 
@@ -44,14 +55,15 @@ const isPlaceName = (tokens: readonly Token[], span: Span, topUnits: ReadonlySet
  * 住所か名前かは、助数詞を外した残りで決める（1日日本銀行の「日本銀行」）。品詞が無ければ判定しない。
  */
 const measuredRun = (tokens: readonly Token[] | undefined, run: KanjiRun, topUnits: ReadonlySet<string>): string => {
+  if (run.quoted) return "";
   if (tokens === undefined || run.span === undefined) return run.text;
   const counter = leadingCounter(tokens, run.span.start, run.text);
   const rest = counter === undefined ? run.span : { start: counter.span.end, end: run.span.end };
   return isPlaceName(tokens, rest, topUnits) ? "" : run.text.slice(counter?.surface.length ?? 0);
 };
 
-const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined, topUnits: ReadonlySet<string>): string =>
-  runsOf(sentence, profile)
+const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined, topUnits: ReadonlySet<string>, names: readonly string[]): string =>
+  runsOf(sentence, profile, names)
     .map((run) => measuredRun(sentence.tokens, run, topUnits))
     .reduce((longest, run) => (run.length > longest.length ? run : longest), "");
 
@@ -62,7 +74,7 @@ const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined,
 export const kanjiRun: Detector = (doc, options): Finding[] => {
   const topUnits = new Set((doc.lexicons["prefecture-unit"] ?? []).map((entry) => entry.pattern));
   return doc.sentences
-    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile, topUnits) }))
+    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile, topUnits, doc.names ?? []) }))
     .filter(({ run }) => run.length > options.limit)
     .map(({ sentence, run }) => ({
       rule: "max-kanji-continuous",

package/src/detectors/en-shape.ts

@@ -79,11 +79,11 @@ const firstWord = (sentence: Sentence): string =>
  * 何が主張なのかが分からなくなる。
  */
 export const conjunctionRun: Detector = (doc, options): Finding[] => {
-  const heads = (options.lexicon ?? []).map((entry) => entry.pattern.toLowerCase());
+  const heads = new Set((options.lexicon ?? []).map((entry) => entry.pattern.toLowerCase()));
   const runs = doc.sentences.filter(isClosed).reduce<Sentence[][]>(
     (acc, sentence) => {
       const last = acc.at(-1) ?? [];
-      if (!heads.includes(firstWord(sentence).toLowerCase())) return [...acc.slice(0, -1), last, []];
+      if (!heads.has(firstWord(sentence).toLowerCase())) return [...acc.slice(0, -1), last, []];
       return [...acc.slice(0, -1), [...last, sentence]];
     },
     [[]],
@@ -153,7 +153,8 @@ const depthsOf = (tokens: readonly Token[]): number[] =>
     { depths: [], open: 0 },
   ).depths;
 
-type Clause = { readonly tokens: readonly Token[]; readonly depths: readonly number[] };
+/** participleWords は、解析器が分詞と読まないが読点のあとで分詞の句を始める語（meaning）。 */
+type Clause = { readonly tokens: readonly Token[]; readonly depths: readonly number[]; readonly participleWords: ReadonlySet<string> };
 
 /** 冠詞や引用符を飛ばした、項目の頭の品詞。the parser と an exporter と samples を同じ形と見る。 */
 const NOMINAL = new Set(["NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
@@ -191,6 +192,21 @@ const itemsBefore = (clause: Clause, at: number): Token[][] => {
     .filter((item) => item.length > 0);
 };
 
+/**
+ * and / or で始まる項目で、前の並びは閉じている（offering, giving, or receiving, directly or indirectly）。
+ * 次の並びはその項目から始まる。項目が動詞で始まれば、その目的語から（Develop, maintain, and track courses, materials and events）。
+ */
+const afterClosedList = (items: readonly Token[][]): Token[][] => {
+  const closed = items.findLastIndex((item) => LIST_CONJUNCTION.has(openingOf(item)?.surface.toLowerCase() ?? ""));
+  const closing = items[closed];
+  if (closing === undefined) return [...items];
+  const body = closing.slice(closing.findIndex((token) => LIST_CONJUNCTION.has(token.surface.toLowerCase())) + 1);
+  const head = body.findIndex(isContent);
+  const rest = VERBAL.has(body[head]?.pos ?? "") ? body.slice(head + 1) : body;
+  // 項目が残らなければ、後ろは新しい句の頭。導入の句（directly or indirectly,）を外す。
+  return rest.some(isContent) ? [rest, ...items.slice(closed + 1)] : [...withoutLead(items.slice(closed + 1))];
+};
+
 /** and / or の後ろの項目。次の読点か節の切れ目まで。 */
 const itemAfter = (tokens: readonly Token[], at: number): Token[] => {
   const end = tokens.findIndex((token, index) => index > at && (isComma(token) || CLAUSE_BREAK.has(token.surface)));
@@ -232,7 +248,9 @@ const joinAdjectives = (items: readonly Token[][]): Token[][] =>
   items.reduce<Token[][]>((joined, item) => {
     const previous = joined.at(-1);
     const stacked = previous !== undefined && lastContent(previous)?.pos === "ADJ" && lastContent(item)?.pos !== "ADJ";
-    return stacked ? [...joined.slice(0, -1), [...previous, ...item]] : [...joined, item];
+    if (stacked) joined[joined.length - 1] = [...previous, ...item];
+    else joined.push(item);
+    return joined;
   }, []);
 
 /**
@@ -255,14 +273,93 @@ const hasVerb = (item: readonly Token[]): boolean => item.some((token) => VERBAL
 
 const predicatesAgree = (items: readonly Token[][], shape: string): boolean => !VERBAL.has(shape) || items.every(hasVerb);
 
+/** -ing 形（VerbForm=Ger）と過去分詞（Part）。filling the gaps と sentenced to prison は並べても並列にならない。 */
+const VERB_FORMS = new Set(["Ger", "Part"]);
+
+const verbFormOf = (token: Token): string | undefined => {
+  const form = token.features?.["VerbForm"];
+  return form !== undefined && VERB_FORMS.has(form) ? form : undefined;
+};
+
+/** 項目の頭の分詞とその形。副詞は飛ばす（originally written）。引用符の中の語（‘modelling’）は語の例なので分詞と読まない。 */
+const participleOpening = (item: readonly Token[], words: ReadonlySet<string>): { readonly at: number; readonly form: string } | undefined => {
+  const at = item.findIndex((token) => token.pos !== "PUNCT" && token.pos !== "ADV");
+  const opening = item[at];
+  if (opening === undefined) return undefined;
+  const form = words.has(opening.surface.toLowerCase()) ? "Ger" : verbFormOf(opening);
+  return form === undefined ? undefined : { at, form };
+};
+
+const hasParticiple = (item: readonly Token[], form: string): boolean => item.some((token) => verbFormOf(token) === form);
+
+/**
+ * 最初より後ろの項目が分詞で始まるとき。最初の項目にも同じ形の分詞があれば分詞の並び
+ * （are hiring engineers, buying laptops and renting desks / Tested, reviewed and approved）。後ろの項目が動詞で始まれば述語の並びで、
+ * 分詞は解析器の読み違い（the jury, cross-examined the witnesses, presented witnesses, and made）。そうでなければ分詞の句
+ * （from Latin, meaning ship or boat / the judge, sitting without a jury, and sentenced）で、並びがあるならその句の中から始まる。
+ * 分詞より前の項目と分詞そのものは項目ではない（programs, including the office, the desk and the team）。句の中の項目の形が揃わなければ
+ * 句は挿入で、並びは句の後ろだけ（relief, including an injunction, in any court ... and without / including before the date, to a
+ * Recipient ... “confidential”, “proprietary”, or the like）。
+ */
+/** 解析器は過去形と過去分詞（fixed）を見分けられない。動詞のある項目のあとの「過去分詞」の並びは、述語の並びと読む。 */
+const pastPredicates = (first: readonly Token[], form: string, after: readonly Token[], words: ReadonlySet<string>): boolean =>
+  form === "Part" && participleOpening(after, words)?.form === "Part" && hasVerb(first);
+
+const fromParticiplePhrase = (items: readonly Token[][], after: readonly Token[], words: ReadonlySet<string>): readonly Token[][] => {
+  const at = items.findIndex((item, index) => index > 0 && participleOpening(item, words) !== undefined);
+  const phrase = items[at];
+  const first = items[0];
+  const opening = phrase === undefined ? undefined : participleOpening(phrase, words);
+  if (first === undefined || phrase === undefined || opening === undefined) return items;
+  const rest = items.slice(at + 1);
+  const predicates = rest.some((item) => VERBAL.has(shapeOf(item) ?? "")) || pastPredicates(first, opening.form, after, words);
+  if (hasParticiple(first, opening.form) || predicates) return items;
+  const inPhrase = withoutLead([phrase.slice(opening.at + 1), ...rest].filter((item) => item.some(isContent)));
+  return new Set(inPhrase.map(shapeOf)).size > 1 ? rest : inPhrase;
+};
+
+const APPOSITIVE_ANCHOR = new Set(["NOUN", "PROPN"]);
+
+/**
+ * 名詞のすぐ後ろの、読点で挟まれた X and Y は同格（two HPV types, HPV16 and HPV18, that account / Governments, both state and
+ * federal, spend）。項目が 2 つに見え、and の前に読点が無く、and の後ろの項目が読点で閉じ、後ろの 2 つに動詞が無いときに同格と読む。
+ * 2 つを結ぶ同格に Oxford comma は打たないので、and の前に読点があれば 3 つの並び（the subcommittee, full committee, and
+ * chamber levels, as well as）。読点の無い本当の並び（apples, pears and plums, then ...）はこの形と見分けられず、判定から外れる。
+ */
+const isAppositive = (clause: Clause, at: number, items: readonly Token[][], after: readonly Token[]): boolean => {
+  const [anchor, head] = items;
+  if (items.length !== 2 || anchor === undefined || head === undefined || commaBefore(clause.tokens, at)) return false;
+  const end = at + 1 + after.length;
+  // 閉じた読点のあとに and / or が続くなら、並びのあとに節をつないでいる（apples, pears and plums, and went home）。
+  const joinsClause = LIST_CONJUNCTION.has(clause.tokens[end + 1]?.surface.toLowerCase() ?? "");
+  const closed = clause.tokens[end]?.surface === "," && clause.depths[end] === clause.depths[at] && !joinsClause;
+  return closed && APPOSITIVE_ANCHOR.has(lastContent(anchor)?.pos ?? "") && !hasVerb(head) && !hasVerb(after);
+};
+
+/** 副詞を飛ばした頭の形。explain and justify と ultimately ensure は同じ動詞の項目。 */
+const leadShape = (item: readonly Token[]): string | undefined => shapeOf(item.filter((token) => token.pos !== "ADV"));
+
+/**
+ * and の後ろの項目に読点と、同じ形の項目を連れた and / or が続くなら、この and は項目の中にある（searches and seizures, and
+ * the Eighth's ban）。頭の形か、節かどうかが違えば別の節をつなぐ and で、この and までが並び（apples, pears and plums, and went home / and figs fell）。
+ */
+const listContinues = (clause: Clause, at: number, after: readonly Token[]): boolean => {
+  const next = at + 1 + after.length;
+  if (clause.tokens[next]?.surface !== "," || !LIST_CONJUNCTION.has(clause.tokens[next + 1]?.surface.toLowerCase() ?? "")) return false;
+  const following = itemAfter(clause.tokens, next + 1);
+  const shape = leadShape(following);
+  return shape !== undefined && shape === leadShape(after) && isClause(following) === isClause(after);
+};
+
 /**
  * 読点で区切った項目が and / or の前に 2 つ以上あり、最後の項目と and の後ろが同じ形のときだけ並列。
  * 導入の読点（After the review, the team fixed the bug and shipped it.）や、節をつなぐ読点
  * （We tested it, and the team shipped it.）は、Oxford comma を打つかどうかの選択を見せない。
  */
 const listAt = (clause: Clause, at: number): boolean | undefined => {
-  const items = withoutLead(joinAdjectives(itemsBefore(clause, at)));
   const after = itemAfter(clause.tokens, at);
+  const items = fromParticiplePhrase(afterClosedList(withoutLead(joinAdjectives(itemsBefore(clause, at)))), after, clause.participleWords);
+  if (listContinues(clause, at, after) || isAppositive(clause, at, items, after)) return undefined;
   const last = items.at(-1);
   const shape = last === undefined ? undefined : shapeOf(last);
   if (items.length < 2 || shape === undefined || shape !== shapeOf(after)) return undefined;
@@ -276,8 +373,8 @@ const listAt = (clause: Clause, at: number): boolean | undefined => {
  * どちらが正しいかは決めない。スタイルガイドで割れる論点に立場を取ると rule ごと無視される。
  * 見るのは 1 つの文書で揃っているかだけ。spec §12.3。
  */
-const oxfordIn = (tokens: readonly Token[]): boolean | undefined => {
-  const clause = { tokens, depths: depthsOf(tokens) };
+const oxfordIn = (tokens: readonly Token[], participleWords: ReadonlySet<string>): boolean | undefined => {
+  const clause = { tokens, depths: depthsOf(tokens), participleWords };
   return tokens.reduce<boolean | undefined>(
     (found, token, at) => found ?? (at > 0 && LIST_CONJUNCTION.has(token.surface.toLowerCase()) ? listAt(clause, at) : undefined),
     undefined,
@@ -285,8 +382,9 @@ const oxfordIn = (tokens: readonly Token[]): boolean | undefined => {
 };
 
 export const oxfordComma: Detector = (doc, options): Finding[] => {
+  const participleWords = new Set((doc.lexicons["participle-word"] ?? []).map((entry) => entry.pattern.toLowerCase()));
   const judged = doc.sentences.flatMap((sentence) => {
-    const oxford = oxfordIn(sentence.tokens ?? []);
+    const oxford = oxfordIn(sentence.tokens ?? [], participleWords);
     return oxford === undefined ? [] : [{ sentence, oxford }];
   });
   const withComma = judged.filter((entry) => entry.oxford).length;