chaffjs 0.25.0 → 0.27.0

package/src/grade/text.ts

@@ -13,6 +13,8 @@ export type GradeText = {
   readonly unknownRule: string;
   readonly rubricProblem: (problem: RubricProblem) => string;
   readonly penalty: (total: number) => string;
+  /** The outputs at each level of the AI-likeness quick score. */
+  readonly aiScore: (low: number, medium: number, high: number, notScored: number) => string;
   readonly noStructure: (source: string, language: string) => string;
   readonly unreadable: (path: string, why: string) => string;
   readonly problem: (problem: ItemProblem) => string;
@@ -110,6 +112,8 @@ export const GRADE_TEXT: Texts<GradeText> = {
     unknownRule: "grade: に書かれているが、chaff の知らないルール",
     rubricProblem: (problem) => `chaff.yaml の ${problem.path} は${EXPECTED_JA[problem.expected]}で書いてください（書かれていたのは ${problem.written}）`,
     penalty: (total) => `減点の和: ${String(total)}`,
+    aiScore: (low, medium, high, notScored) =>
+      `AI らしさ: 低 ${String(low)}、中 ${String(medium)}、高 ${String(high)}、測っていない ${String(notScored)}（書いたのが AI かどうかの判定ではありません。合否には入りません）`,
     noStructure: (source, language) => `原文 ${source} の言語 ${language} のパッケージは文書の構造を読めない`,
     unreadable: (path, why) => `${path} を読めませんでした: ${why}`,
     problem: (problem) => PROBLEM_JA[problem.kind](problem),
@@ -142,6 +146,8 @@ export const GRADE_TEXT: Texts<GradeText> = {
     unknownRule: "named under grade: but not a rule chaff knows",
     rubricProblem: (problem) => `chaff.yaml: ${problem.path} must be ${EXPECTED_EN[problem.expected]} (found ${problem.written})`,
     penalty: (total) => `Penalty points: ${String(total)}`,
+    aiScore: (low, medium, high, notScored) =>
+      `AI-likeness: low ${String(low)}, medium ${String(medium)}, high ${String(high)}, not scored ${String(notScored)} (not a verdict on whether AI wrote them; not part of pass or fail)`,
     noStructure: (source, language) => `the ${language} package cannot read the structure of source ${source}`,
     unreadable: (path, why) => `Could not read ${path}: ${why}`,
     problem: (problem) => PROBLEM_EN[problem.kind](problem),

package/src/grade/variants-text.ts

@@ -10,6 +10,9 @@ export type VariantText = {
   readonly citationsCell: (failed: number, checked: number) => string;
   readonly unsupportedFacts: string;
   readonly penalty: string;
+  /** The row of the AI-likeness quick score, and its cell: outputs at low / medium / high, then (not scored). */
+  readonly aiScore: string;
+  readonly aiScoreCell: (low: number, medium: number, high: number, notScored: number) => string;
   readonly ratesHeading: (unit: string) => string;
   readonly unit: Readonly<Record<"char" | "word", string>>;
   readonly disagreeHeading: (count: number) => string;
@@ -40,6 +43,8 @@ export const VARIANT_TEXT: Texts<VariantText> = {
     citationsCell: (failed, checked) => `${String(failed)}/${String(checked)}`,
     unsupportedFacts: "一節に無い事実",
     penalty: "減点の和",
+    aiScore: "AI らしさ 低/中/高",
+    aiScoreCell: (low, medium, high, notScored) => `${String(low)}/${String(medium)}/${String(high)}（${String(notScored)}）`,
     ratesHeading: (unit) => `ルールごとの率（1,000 ${unit}あたり）`,
     unit: { char: "字", word: "語" },
     disagreeHeading: (count) => `合否が分かれた出力 ${String(count)} 件`,
@@ -68,6 +73,8 @@ export const VARIANT_TEXT: Texts<VariantText> = {
     citationsCell: (failed, checked) => `${String(failed)}/${String(checked)}`,
     unsupportedFacts: "Unsupported facts",
     penalty: "Penalty points",
+    aiScore: "AI low/med/high",
+    aiScoreCell: (low, medium, high, notScored) => `${String(low)}/${String(medium)}/${String(high)} (${String(notScored)})`,
     ratesHeading: (unit) => `Rule rates (per 1,000 ${unit})`,
     unit: { char: "characters", word: "words" },
     disagreeHeading: (count) => `${String(count)} ${count === 1 ? "output" : "outputs"} where pass or fail differs`,

package/src/grade/variants.ts

@@ -1,6 +1,7 @@
 import type { LengthUnit } from "../plugin.ts";
 import { rateRows, sameReading } from "./pairing.ts";
 import type { GradeResult } from "./result.ts";
+import type { AiLevelCounts } from "./ai-score.ts";
 import { summaryOf } from "./summary.ts";
 import { variantGroupsOf, type VariantGroups } from "./variants-input.ts";
 
@@ -21,6 +22,8 @@ export type VariantColumn = {
   readonly contexts?: { readonly checked: number; readonly unsupported: number } | undefined;
   /** Only with a `grade:` rubric. */
   readonly penalty?: number | undefined;
+  /** The outputs at each level of the AI-likeness quick score. Absent when no result carries one. */
+  readonly aiScore?: AiLevelCounts | undefined;
 };
 
 /** One rule's rate per 1,000 units in each variant, by variant label; 0 where the variant had no finding of it. */
@@ -66,6 +69,7 @@ const columnOf = (variant: string, results: readonly GradeResult[]): VariantColu
     citations: summary.citations,
     ...(summary.contexts === undefined ? {} : { contexts: { checked: summary.contexts.checked, unsupported: sum(summary.contexts.unsupported) } }),
     ...(summary.penalty === undefined ? {} : { penalty: summary.penalty }),
+    ...(summary.aiScore === undefined ? {} : { aiScore: summary.aiScore }),
   };
 };
 

package/src/grade-api.ts

@@ -5,7 +5,8 @@ import { statSync } from "node:fs";
 import { resolve } from "node:path";
 import { packageFor } from "./adapter-load.ts";
 import { CLI_TEXT } from "./cli-text.ts";
-import { EMPTY, loadConfig, type Config } from "./config/load.ts";
+import { EMPTY, type Config } from "./config/load.ts";
+import { loadConfig } from "./config/read.ts";
 import { withStyle } from "./config/style.ts";
 import { withExtensions } from "./extension/load.ts";
 import { GENRES } from "./genre.ts";
@@ -35,6 +36,7 @@ export type {
   SupportedFact,
 } from "./grade/result.ts";
 export type { OutputSize } from "./grade/rates.ts";
+export type { AiLevelCounts, GradeAiScore } from "./grade/ai-score.ts";
 export { toScorer, type ChaffScore } from "./grade/scorer.ts";
 export type { Disagreement, VariantColumn, VariantComparison, VariantRates } from "./grade/variants.ts";
 export type { VariantInput } from "./grade/variants-input.ts";

package/src/judge.ts

@@ -78,8 +78,6 @@ export type JudgeOptions = {
 const judgeFor = (options: JudgeOptions): Judge =>
   options.backend === "openai" ? openai.judge(options.openaiClient) : anthropic.judge(options.anthropicClient);
 
-export const defaultModel = (backend: BackendName): string => (backend === "openai" ? openai.DEFAULT_MODEL : anthropic.DEFAULT_MODEL);
-
 export const hasCredentials = (backend: BackendName): boolean => (backend === "openai" ? openai.hasCredentials() : anthropic.hasCredentials());
 
 export const isAuthFailure = (backend: BackendName, error: unknown): boolean =>

package/src/known-genres.ts

@@ -1,6 +1,6 @@
-import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parse } from "yaml";
+import { exists, readText } from "./package-files.ts";
 import { loadGenres } from "./genre-load.ts";
 import { parseGenres, type GenreData } from "./genre-parse.ts";
 
@@ -15,5 +15,5 @@ export const knownGenres = (): string[] => idsOf(loadGenres());
  */
 export const genresBeside = (rulesDir: string): string[] => {
   const file = join(rulesDir, "..", "genres.yaml");
-  return existsSync(file) ? idsOf(parseGenres(parse(readFileSync(file, "utf8")))) : knownGenres();
+  return exists(file) ? idsOf(parseGenres(parse(readText(file)))) : knownGenres();
 };

package/src/package-files.ts

@@ -0,0 +1,15 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Every read of a file chaff ships (rules, genres, profiles, styles) goes through here, so a build without a file
+// system can put its own reads in this module's place. The functions take any path, as the callers always have.
+
+/** The package's folder: src/ and dist/ both sit right under it. */
+export const PACKAGE_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+export const readText = (path: string): string => readFileSync(path, "utf8");
+
+export const readDir = (path: string): string[] => readdirSync(path);
+
+export const exists = (path: string): boolean => existsSync(path);

package/src/profile/load.ts

@@ -1,22 +1,21 @@
-import { readFileSync, readdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { parse } from "yaml";
+import { PACKAGE_DIR, readDir, readText } from "../package-files.ts";
 import { parseProfile, type ProfileDefinition } from "./parse.ts";
 
-const PROFILES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "profiles");
+const PROFILES_DIR = join(PACKAGE_DIR, "profiles");
 
 const loaded: { value: readonly ProfileDefinition[] | undefined } = { value: undefined };
 
 /** 同梱の profiles/*.yaml。一度だけ読む。 */
 export const loadProfiles = (): readonly ProfileDefinition[] => {
-  loaded.value ??= readdirSync(PROFILES_DIR)
+  loaded.value ??= readDir(PROFILES_DIR)
     .filter((file) => file.endsWith(".yaml"))
     .toSorted((left, right) => left.localeCompare(right))
     .flatMap((file) => {
       const path = join(PROFILES_DIR, file);
       try {
-        const definition = parseProfile(parse(readFileSync(path, "utf8")));
+        const definition = parseProfile(parse(readText(path)));
         return definition === undefined ? [] : [definition];
       } catch (error) {
         throw new Error(`cannot read the profile ${path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });

package/src/rule-load.ts

@@ -1,6 +1,4 @@
-import { readFileSync, readdirSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { parse } from "yaml";
 import type { LanguageLevels, LevelSets, LevelTable, RuleDefinition, Severity } from "./plugin.ts";
 import { rankOfSeverity, severityAt } from "./levels.ts";
@@ -8,8 +6,9 @@ import { optionsOf } from "./rule-options.ts";
 import { ruleGuideOf } from "./rule-guide.ts";
 import { fieldProblemSentence, fieldProblems } from "./rule-fields.ts";
 import { genresBeside } from "./known-genres.ts";
+import { PACKAGE_DIR, readDir, readText } from "./package-files.ts";
 
-const RULES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "rules");
+const RULES_DIR = join(PACKAGE_DIR, "rules");
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 
@@ -191,7 +190,7 @@ const ruleOf = (raw: Record<string, unknown>, levels: LevelTable, levelSets: Lev
  */
 const parseRule = (dir: string, file: string): unknown => {
   try {
-    return parse(readFileSync(join(dir, file), "utf8"));
+    return parse(readText(join(dir, file)));
   } catch (error) {
     throw new Error(`${file} を読めません: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`, { cause: error });
   }
@@ -199,7 +198,7 @@ const parseRule = (dir: string, file: string): unknown => {
 
 export const loadRules = (language: string, dir: string = RULES_DIR): RuleDefinition[] => {
   const genres = genresBeside(dir);
-  return readdirSync(dir)
+  return readDir(dir)
     .filter((file) => file.endsWith(".yaml"))
     .toSorted((left, right) => left.localeCompare(right, "en"))
     .map((file) => toRule(parseRule(dir, file), language, file, genres));

package/src/rule-offs.ts

@@ -1,6 +1,6 @@
-import { readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { parse } from "yaml";
+import { readDir, readText } from "./package-files.ts";
 
 /** One rule a group or genre turns off by default, from the rule file's off_for, with why. */
 export type RuleOff = { readonly rule: string; readonly target: string; readonly reason: string };
@@ -34,7 +34,7 @@ const offForBlock = (rule: string, text: string): string | undefined => {
 /** The offs of one rule file. The rule is named by the file, which is named by the rule's id. */
 const offsInFile = (dir: string, file: string): RuleOff[] => {
   const rule = file.replace(/\.yaml$/u, "");
-  const block = offForBlock(rule, readFileSync(join(dir, file), "utf8").replaceAll("\r\n", "\n"));
+  const block = offForBlock(rule, readText(join(dir, file)).replaceAll("\r\n", "\n"));
   const parsed: unknown = block === undefined ? undefined : parse(block);
   return ruleOffsOf(rule, isRecord(parsed) ? parsed["off_for"] : undefined);
 };
@@ -44,7 +44,7 @@ const offsInFile = (dir: string, file: string): RuleOff[] => {
  * at startup, before any rule is.
  */
 export const loadRuleOffs = (dir: string): RuleOff[] =>
-  readdirSync(dir)
+  readDir(dir)
     .filter((file) => file.endsWith(".yaml"))
     .toSorted((left, right) => left.localeCompare(right, "en"))
     .flatMap((file) => offsInFile(dir, file));

package/src/run.ts

@@ -15,7 +15,7 @@ import { presetLevels } from "./genre-load.ts";
 import { bodySectionOf } from "./body-section.ts";
 import { optionValues, settleOptions, type OptionLayer } from "./rule-options.ts";
 import { byPosition } from "./finding-order.ts";
-import { PatternTimeout } from "./custom/bounded-match.ts";
+import { PatternTimeout } from "./custom/pattern-timeout.ts";
 import { PluginRuleFailure } from "./extension/module-detector.ts";
 import { failureReason } from "./extension/failure-text.ts";
 import { tagCoverage } from "./tag-coverage.ts";

package/src/structure/change-rate.ts

@@ -0,0 +1,103 @@
+// A rate of change written beside the two values it is computed from (「前年同月の1,000社から20%増えました」 with 1,200社,
+// "up 20% from 1,000 companies" with 1,200 companies) that the two values do not give. Pure; the detector reads the
+// figures, the rate and the words from the tree and the language's lexicons.
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/** A value with its unit as the sentence compares it (円, 社, $, companies) and the step it is written to (1 for 1,200; 1億 for 12億). */
+export type Figure = Span & { readonly value: number; readonly unit: string; readonly step: number };
+/** A percentage, with the number of decimals written. */
+export type Rate = Span & { readonly value: number; readonly decimals: number };
+/** A word that says which way the value moved (増加, up: 1; 減少, down: -1). */
+export type Direction = Span & { readonly sign: 1 | -1 };
+/** A word that marks a value: the earlier one after it (「1,000社から」) or before it ("from 1,000"), the later one (「1,200社に」, "to 1,200"). */
+export type BaseMark = Span & { readonly position: "before" | "after" };
+
+export type ChangeText = {
+  readonly sentences: readonly Span[];
+  readonly figures: readonly Figure[];
+  readonly rates: readonly Rate[];
+  readonly directions: readonly Direction[];
+  readonly marks: readonly BaseMark[];
+  /** Words that mark the later value ("to", 「に」). */
+  readonly targets: readonly BaseMark[];
+};
+
+/** How far a direction word may stand from the rate (「20%の増加」「20%増えました」, "an increase of 20%", "up 20%"). */
+const DIRECTION_REACH = 8;
+/** How far a base mark may stand from its value ("from $10" has the currency sign between). */
+const MARK_GAP = 3;
+/**
+ * How far the earlier value may stand from the rate (「1,000社から20%」「10億円に比べて20%」"20% from $10 million"). Further
+ * away, the rate is of something else in the sentence (「100店から120店に増え、売上は15%増えた」).
+ */
+const BASE_REACH = 12;
+const PERCENT = 100;
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+
+const within = (outer: Span, inner: Span): boolean => inner.start >= outer.start && inner.end <= outer.end;
+
+const distance = (left: Span, right: Span): number => Math.max(left.start - right.end, right.start - left.end, 0);
+
+const markOf = (figure: Figure, marks: readonly BaseMark[]): BaseMark | undefined =>
+  marks.find((mark) => {
+    const gap = mark.position === "after" ? mark.start - figure.end : figure.start - mark.end;
+    return gap >= 0 && gap <= MARK_GAP;
+  });
+
+/** The earlier value: marked, with the value or its mark beside the rate ("up 25% compared with $1,000"). */
+const isBaseFor = (figure: Figure, rate: Rate, marks: readonly BaseMark[]): boolean => {
+  const mark = markOf(figure, marks);
+  return mark !== undefined && Math.min(distance(figure, rate), distance(mark, rate)) <= BASE_REACH;
+};
+
+/**
+ * The later value is written before the rate (「1,200社となり、…20%増えました」"1,200 companies, up 20%") or marked as the
+ * value reached (「1,200社に」"to 1,200"). Another amount after the rate is about something else ("…, and revenue was $1,300").
+ */
+const isCurrentFor = (figure: Figure, rate: Rate, targets: readonly BaseMark[]): boolean => figure.end <= rate.start || markOf(figure, targets) !== undefined;
+
+/** The one sign the direction words beside the rate agree on. */
+const signNear = (rate: Rate, directions: readonly Direction[]): 1 | -1 | undefined => {
+  const signs = new Set(directions.filter((direction) => distance(direction, rate) <= DIRECTION_REACH).map((direction) => direction.sign));
+  const [sign] = signs;
+  return signs.size === 1 ? sign : undefined;
+};
+
+/**
+ * The rates of change the two values allow. Each value may be off by half the step it is written to: 12億 is anything from
+ * 11.5億 to 12.5億, so 12億 from 10億 is a rise of 9.5% to 31.6%, and only a rate outside that is a mistake.
+ */
+const rateRange = (base: Figure, current: Figure): readonly [number, number] | undefined => {
+  const [baseLow, baseHigh] = [base.value - base.step * HALF, base.value + base.step * HALF];
+  const [currentLow, currentHigh] = [current.value - current.step * HALF, current.value + current.step * HALF];
+  if (baseLow <= 0) return undefined;
+  return [(currentLow / baseHigh - 1) * PERCENT, (currentHigh / baseLow - 1) * PERCENT];
+};
+
+const issueIn = (text: ChangeText, sentence: Span): StructureIssue[] => {
+  const rates = text.rates.filter((rate) => within(sentence, rate));
+  const figures = text.figures.filter((figure) => within(sentence, figure));
+  const [rate] = rates;
+  if (rates.length !== 1 || rate === undefined) return [];
+  const sign = signNear(
+    rate,
+    text.directions.filter((direction) => within(sentence, direction)),
+  );
+  const bases = figures.filter((figure) => isBaseFor(figure, rate, text.marks));
+  const [base] = bases;
+  if (sign === undefined || bases.length !== 1 || base === undefined) return [];
+  const currents = figures.filter((figure) => figure !== base && figure.unit === base.unit && isCurrentFor(figure, rate, text.targets));
+  const [current] = currents;
+  const range = currents.length === 1 && current !== undefined ? rateRange(base, current) : undefined;
+  if (range === undefined || current === undefined) return [];
+  const written = sign * rate.value;
+  const slack = HALF * DECIMAL_BASE ** -rate.decimals;
+  if (written >= range[0] - slack && written <= range[1] + slack) return [];
+  const computed = Math.abs((current.value / base.value - 1) * PERCENT).toFixed(rate.decimals);
+  return [{ offset: rate.start, values: { rate: String(rate.value), computed } }];
+};
+
+/** Each sentence with one rate of change, one direction, one marked earlier value and one other value in its unit, that disagree. */
+export const changeRateMismatches = (text: ChangeText): StructureIssue[] => text.sentences.flatMap((sentence) => issueIn(text, sentence));

package/src/structure/date-range.ts

@@ -18,6 +18,29 @@ export type RangeWords = {
   readonly frames: readonly RangeFrame[];
   /** 同じ文にあれば、組を期間ではなく日付の変更と読む語（moved from … to、… was postponed）。 */
   readonly changes: readonly string[];
+  /** 日付の前に添える曜日の名（Wednesday, April 1, 2026）。つなぎ目と前の語を読むときに除く。無ければ空。 */
+  readonly weekdays?: readonly string[];
+};
+
+/** 曜日の略し方の短いほう（Tue、Wed）。名の頭のこの字数以上が書いてあれば、その曜日と読む。 */
+const WEEKDAY_ABBREVIATION = 3;
+const LETTER = /\p{L}/u;
+
+/** The text's last word (past a full stop) and where it starts. */
+const lastWord = (text: string): { readonly word: string; readonly start: number } => {
+  const body = text.endsWith(".") ? text.slice(0, -1) : text;
+  const chars = [...body];
+  const start = chars.findLastIndex((char) => !LETTER.test(char)) + 1;
+  return { word: chars.slice(start).join(""), start: chars.slice(0, start).join("").length };
+};
+
+/** 終わりに付いた曜日の名か略し方とその後ろのコンマ（"to tuesday," の tuesday,、"from wed." の wed.）を除く。 */
+export const withoutTrailingWeekday = (text: string, weekdays: readonly string[]): string => {
+  const trimmed = text.replace(/,$/u, "").trimEnd();
+  const { word, start } = lastWord(trimmed);
+  const lower = word.toLowerCase();
+  const isWeekday = lower.length >= WEEKDAY_ABBREVIATION && weekdays.some((name) => name.toLowerCase().startsWith(lower));
+  return isWeekday ? trimmed.slice(0, start).trimEnd() : text;
 };
 
 export type RangeFrame = { readonly lead: string; readonly joint: string };
@@ -87,13 +110,15 @@ const sentenceAround = (source: string, start: DatedSpan, end: DatedSpan): { rea
 /** 前の語と間の語の組（from … to）。同じ文のどこかに変更の語（moved、postponed）があれば、日付を動かした文で、期間ではない。 */
 const framed = (source: string, start: DatedSpan, end: DatedSpan, joint: string, words: RangeWords): boolean => {
   const sentence = sentenceAround(source, start, end);
-  const frame = words.frames.find((candidate) => candidate.joint === joint && endsWithWord(sentence.before, candidate.lead));
+  const before = withoutTrailingWeekday(sentence.before, words.weekdays ?? []);
+  const frame = words.frames.find((candidate) => candidate.joint === joint && endsWithWord(before, candidate.lead));
   return frame !== undefined && !words.changes.some((change) => hasWord(sentence.text, change.toLowerCase()));
 };
 
 const isRange = (source: string, start: DatedSpan, end: DatedSpan, words: RangeWords): boolean => {
-  const joint = jointOf(source, start, end);
-  if (joint === undefined) return false;
+  const written = jointOf(source, start, end);
+  if (written === undefined) return false;
+  const joint = withoutTrailingWeekday(written, words.weekdays ?? []);
   return (
     isOneOf(joint, words.connectors) || (isOneOf(joint, words.openers) && closedAfter(source, end, words.closers)) || framed(source, start, end, joint, words)
   );

package/src/structure/issues.ts

@@ -31,8 +31,9 @@ const textOf = (node: StructureNode, key: string): string => {
  * 参照がこの文書のどこかを指しているか。fallback は言語パッケージが付ける別の行き先で、
  * 日本語の「第4条第1項」は、番号の無い第 1 項を持つ第4条を指しうる。
  */
-const resolves = (node: StructureNode, addresses: ReadonlySet<string>): boolean =>
-  addresses.has(textOf(node, "target")) || (node.attrs["fallback"] !== undefined && addresses.has(fallbackKey(node)));
+const resolves = (node: StructureNode, addresses: ReadonlySet<string>, chapters: Chapters): boolean =>
+  addresses.has(textOf(node, "target")) ||
+  (node.attrs["fallback"] !== undefined && chapterReading(textOf(node, "target"), chapters).fallback && addresses.has(fallbackKey(node)));
 
 /**
  * fallbackLabel があれば、fallback はその見出しの番号で書かれた節点だけに当たる。
@@ -48,6 +49,53 @@ const addressesOf = (node: StructureNode): string[] =>
 
 const keysOf = (node: StructureNode): string[] => addressesOf(node).flatMap((address) => [address, labelled(address, textOf(node, "label"))]);
 
+/** An address without its numbers: the kind of unit it names (ch9 and ch10 are both ch). */
+const unitOf = (address: string): string => address.replaceAll(/[\d.]+/gu, "");
+
+/** The document's chapters: their addresses, and whether the one chapter is the document itself (its title, first of all). */
+export type Chapters = { readonly addresses: readonly string[]; readonly titled: boolean };
+
+/**
+ * How a document's chapters bear on a reference to a chapter (第9章, Chapter 9). Pure.
+ *   fallback: whether the reference may fall back to a numbered section ("## 9. …"). Only in a document with no chapter:
+ *     where chapters are written, a chapter reference names a chapter, and section 9 is not chapter 9.
+ *   elsewhere: the reference names a chapter of another file. A document that is one chapter (第10章 as its title, a series
+ *     of one chapter per file) holds no other chapter, so 第9章 is the next file's. Its own chapter is still its own.
+ */
+export const chapterReading = (target: string, chapters: Chapters): { readonly fallback: boolean; readonly elsewhere: boolean } => {
+  const shortAddresses = chapters.addresses.map((address) => address.slice(address.lastIndexOf("/") + 1));
+  const toChapter = new Set(shortAddresses.map(unitOf)).has(unitOf(target));
+  const series = chapters.titled && chapters.addresses.length === 1 && !shortAddresses.includes(target);
+  return { fallback: !toChapter, elsewhere: toChapter && series };
+};
+
+/** A chapter is the document's title when it is not under another heading (ch10, not h1/ch1) and nothing numbered comes before it. */
+const chaptersOf = (nodes: readonly StructureNode[]): Chapters => {
+  const chapters = nodes.filter((node) => node.kind === "chapter");
+  const first = nodes.find((node) => NUMBERED.has(node.kind));
+  const titled = chapters.length === 1 && first === chapters[0] && !(first?.address.includes("/") ?? true);
+  return { addresses: chapters.map((node) => node.address), titled };
+};
+
+/** What may stand between a chapter and the reference it qualifies: nothing (第1章第2条) or の (第1章の第2条). A list mark (第1章、第2条) names two. */
+const QUALIFIER_GAPS: ReadonlySet<string> = new Set(["", "の"]);
+
+/**
+ * The references that point into another file: a chapter reference read as elsewhere (chapterReading), and the reference
+ * right after one, which it qualifies (第1章の第2条 is article 2 of that other chapter).
+ */
+const elsewhereReferences = (nodes: readonly StructureNode[], source: string): ReadonlySet<StructureNode> => {
+  const chapters = chaptersOf(nodes);
+  const references = nodes.filter((node) => node.kind === "reference");
+  const elsewhere = new Set<StructureNode>();
+  references.forEach((node, index) => {
+    const before = references[index - 1];
+    const qualified = before !== undefined && elsewhere.has(before) && QUALIFIER_GAPS.has(source.slice(before.span.end, node.span.start).trim());
+    if (qualified || chapterReading(textOf(node, "target"), chapters).elsewhere) elsewhere.add(node);
+  });
+  return elsewhere;
+};
+
 /**
  * 他の文書を指す参照か。citedTag（"[HTTP-CACHING]"）は、書き方だけでは差し込み欄の "[BUYER-1]" と見分けられないので、
  * 文書がその語を一覧に載せているときだけ他の文書の名とみなす。
@@ -77,10 +125,12 @@ export const danglingReferences = (tree: StructureNode, source: string): Structu
   const otherNumbering = (node: StructureNode): boolean =>
     numberings.size > 0 && typeof numbering(node) === "string" && !numberings.has(String(numbering(node))) && citedElsewhere.has(numbering(node));
   const articleLabels = nodes.filter((node) => node.kind === "article").map((node) => textOf(node, "label"));
+  const chapters = chaptersOf(nodes);
+  const elsewhere = elsewhereReferences(nodes, source);
   return nodes
     .filter((node) => node.kind === "reference" && !citesOther(node) && !otherNumbering(node))
-    .filter((node) => !namesAbsentUnit(node, articleLabels))
-    .filter((node) => !resolves(node, addresses))
+    .filter((node) => !namesAbsentUnit(node, articleLabels) && !elsewhere.has(node))
+    .filter((node) => !resolves(node, addresses, chapters))
     .map((node) => ({ offset: node.span.start, values: { label: textOf(node, "label"), target: textOf(node, "target") } }));
 };
 
@@ -88,15 +138,20 @@ export const danglingReferences = (tree: StructureNode, source: string): Structu
  * 参照が指す節点。danglingReferences と同じ引き方（番地、章の短い番地、fallback）で、番号の付いたまとまりを引く。
  * 同じ鍵の節点が二つ以上ある（番号の振り直しや別表の条）ときは、どれを指すのか決まらないので undefined。
  */
-export const referenceResolver = (tree: StructureNode): ((reference: StructureNode) => StructureNode | undefined) => {
+export const referenceResolver = (tree: StructureNode, source: string): ((reference: StructureNode) => StructureNode | undefined) => {
+  const nodes = inDocumentOrder(tree);
+  const chapters = chaptersOf(nodes);
+  const elsewhere = elsewhereReferences(nodes, source);
   const byKey = new Map<string, StructureNode | null>();
   inDocumentOrder(tree)
     .filter((node) => NUMBERED.has(node.kind))
     .forEach((node) => keysOf(node).forEach((key) => byKey.set(key, byKey.has(key) && byKey.get(key) !== node ? null : node)));
   const resolve = (reference: StructureNode): StructureNode | undefined => {
+    if (elsewhere.has(reference)) return undefined;
     const target = byKey.get(textOf(reference, "target"));
     if (target !== undefined) return target ?? undefined;
-    return reference.attrs["fallback"] === undefined ? undefined : (byKey.get(fallbackKey(reference)) ?? undefined);
+    const fallback = reference.attrs["fallback"] !== undefined && chapterReading(textOf(reference, "target"), chapters).fallback;
+    return fallback ? (byKey.get(fallbackKey(reference)) ?? undefined) : undefined;
   };
   // Article 6 は Section 6 ではない。番号の書き方が両方にあって違えば、別の文書の条かもしれないので引かない。
   return (reference) => {

package/src/structure/list-numbering.ts

@@ -0,0 +1,34 @@
+// The numbers written on the items of a Markdown ordered list (「1.」「2.」「4.」) that skip or repeat. Markdown renders an
+// ordered list from its first number on, but the source shows the numbers as written, and a "see step 4" points at those.
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+
+const ITEM_NUMBER = /^(?<number>\d{1,9})(?<delimiter>[.)])[ \t]/u;
+
+/** One item's written number: where the item starts, the number and the number as written (「4.」). */
+export type WrittenNumber = { readonly offset: number; readonly number: number; readonly label: string };
+
+/** The number written at the start of each item, or undefined when an item has none (a bulleted list). */
+export const writtenNumbers = (source: string, itemSpans: readonly Span[]): WrittenNumber[] | undefined => {
+  const numbers = itemSpans.map((span) => {
+    const found = ITEM_NUMBER.exec(source.slice(span.start, span.end))?.groups;
+    return found === undefined
+      ? undefined
+      : { offset: span.start, number: Number(found["number"]), label: `${found["number"] ?? ""}${found["delimiter"] ?? ""}` };
+  });
+  return numbers.every((entry) => entry !== undefined) ? numbers : undefined;
+};
+
+/**
+ * Each item whose number is not one more than the item before it. A list that writes one number on every item (「1.」 on
+ * each, which Markdown counts up) is numbered by the renderer, not by the writer, and is not read. An item numbered 1
+ * starts a new count, as the structure rule reads a 1 that follows other items.
+ */
+export const listNumberBreaks = (items: readonly WrittenNumber[]): StructureIssue[] => {
+  if (new Set(items.map((item) => item.number)).size < 2) return [];
+  return items.flatMap((item, index) => {
+    const previous = items[index - 1];
+    if (previous === undefined || item.number === previous.number + 1 || item.number === 1) return [];
+    return [{ offset: item.offset, values: { previous: previous.label, label: item.label, expected: previous.number + 1, found: item.number } }];
+  });
+};

package/src/structure/party-role.ts

@@ -0,0 +1,94 @@
+import type { BodyText, DefinedTerm } from "./definition-use.ts";
+
+/**
+ * 当事者を、定めた呼び名でなく立場の語で書いた所（「乙」と定めたあとの「受託者」、the "Supplier" のあとの the Vendor）。
+ * 当事者の定義は、文の途中で括弧に入れて短い呼び名を定めた所のうち、呼び名が当事者の呼び名の語（甲・乙・当社）か立場の語
+ * そのもの（Supplier）であるもの、または括弧のすぐ前に会社の形（株式会社、Ltd）を書いたもの。語は言語パッケージの語彙表から取る。
+ * 立場の語は、それ自体を定義した語や、定義した語の一部として書いた所（Receiving Party と定義した所の Party）なら指さない。
+ */
+export type PartyWords = {
+  /** 当事者の立場の語（委託者、受託者、Supplier、Recipient）。 */
+  readonly roles: readonly string[];
+  /** 当事者の呼び名に使う語（甲、乙、当社、we）。 */
+  readonly shortNames: readonly string[];
+  /** 会社の形（株式会社、Ltd、Inc.）。 */
+  readonly companyForms: readonly string[];
+};
+
+export type Party = { readonly term: string; readonly end: number };
+export type RoleUse = { readonly offset: number; readonly role: string };
+
+/** 会社の形を探す、括弧の前の幅。名前一つ分。 */
+const NAME_REACH = 40;
+/** 語の前後の一字がこれなら、語は長い語の一部（再受託者、受託者側の「受託者」は語の一部でない側も含む）。 */
+const WORD_CHAR = /[\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}ー]/u;
+const LATIN_START = /^\p{Script=Latin}/u;
+/** 英語の立場の語は、冠詞か所有の語に続く大文字の語だけ（the Vendor）。小文字の the vendor は普通の名詞。 */
+const ENGLISH_LEAD = /(?:^|[^\p{L}])(?:the|The|each|Each|any|Any|such|Such)\s+$/u;
+const LEAD_REACH = 8;
+
+const occurrences = (text: string, word: string): number[] => {
+  const found: number[] = [];
+  let at = text.indexOf(word);
+  while (at !== -1) {
+    found.push(at);
+    at = text.indexOf(word, at + word.length);
+  }
+  return found;
+};
+
+const LETTER = /\p{L}/u;
+
+/** 英字の語は、英字の続き（Including の Inc）では語と読まない。 */
+const wordAt = (text: string, word: string, at: number): boolean =>
+  !LATIN_START.test(word) || (!LETTER.test(text.charAt(at - 1)) && !LETTER.test(text.charAt(at + word.length)));
+
+/** 括弧の前の名前に会社の形があるか。 */
+const namedCompanyBefore = (source: string, definition: DefinedTerm, forms: readonly string[]): boolean => {
+  const before = source.slice(Math.max(0, definition.span.start - NAME_REACH), definition.span.start);
+  return forms.some((form) => form !== "" && occurrences(before, form).some((at) => wordAt(before, form, at)));
+};
+
+/** 文書が当事者として定めた呼び名と、その定義の終わり。 */
+export const partiesOf = (source: string, terms: readonly DefinedTerm[], words: PartyWords): Party[] =>
+  terms
+    .filter((term) => term.inline)
+    .filter((term) => words.shortNames.includes(term.term) || words.roles.includes(term.term) || namedCompanyBefore(source, term, words.companyForms))
+    .map((term) => ({ term: term.term, end: term.span.end }));
+
+/** 英語の立場の語のあとに付いてよいもの: 複数形と所有の形（Vendors、Vendor's）。 */
+const ENGLISH_ENDING = /^(?:s|['’]s?)?(?![\p{L}\p{N}])/u;
+/** 文や項目の頭（"Vendor shall"、"1. Vendor shall"）。 */
+const CLAUSE_START = /^[\s\d.()*+-]*$/u;
+
+/** 英語の立場の語は、冠詞か所有の語のあと（the Vendor）か、文の頭の大文字の語だけ。小文字の the vendor は普通の名詞。 */
+const englishRoleAt = (text: BodyText, at: number, role: string): boolean => {
+  const before = text.text.slice(0, at);
+  return ENGLISH_ENDING.test(text.text.slice(at + role.length)) && (CLAUSE_START.test(before) || ENGLISH_LEAD.test(before.slice(-LEAD_REACH)));
+};
+
+const standsAlone = (source: string, text: BodyText, at: number, role: string): boolean => {
+  const offset = text.start + at;
+  if (WORD_CHAR.test(source.charAt(offset - 1))) return false;
+  return LATIN_START.test(role) ? englishRoleAt(text, at, role) : !/[\p{Script=Han}\p{Script=Katakana}ー]/u.test(source.charAt(offset + role.length));
+};
+
+/** 定義した語がこの位置を覆うか（Receiving Party の Party、本受託者規程の受託者）。 */
+const insideDefined = (source: string, offset: number, role: string, defined: readonly string[]): boolean =>
+  defined.some((term) => term !== role && term.includes(role) && occurrences(term, role).some((at) => source.startsWith(term, offset - at)));
+
+/**
+ * 当事者を定めた後（after より後）で、立場の語を書いた所。立場の語それ自体を定義した文書では、その語は呼び名なので指さない。
+ */
+export const roleUses = (source: string, texts: readonly BodyText[], roles: readonly string[], defined: readonly string[], after: number): RoleUse[] =>
+  roles
+    .filter((role) => role !== "" && !defined.includes(role))
+    .flatMap((role) =>
+      texts.flatMap((text) =>
+        occurrences(text.text, role)
+          .filter((at) => text.start + at > after && standsAlone(source, text, at, role) && !insideDefined(source, text.start + at, role, defined))
+          .map((at) => ({ offset: text.start + at, role })),
+      ),
+    )
+    .toSorted((left, right) => left.offset - right.offset)
+    .filter((use, index, all) => all.findIndex((other) => other.offset <= use.offset && use.offset < other.offset + other.role.length) === index);