chaffjs 0.5.1 → 0.7.0

package/src/detectors/orthography.ts

@@ -0,0 +1,55 @@
+import type { Detector, Finding, Sentence } from "../plugin.ts";
+import { latinBoundaries, minorityStyle, occurrencesOutside, type SpacingKind } from "../orthography.ts";
+
+/** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
+export const preferredTerm: Detector = (doc, options): Finding[] => {
+  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ avoid: entry.pattern, use: entry.instead_of }]));
+  const hits = doc.sentences.flatMap((sentence) =>
+    pairs.flatMap((pair) => occurrencesOutside(sentence.text, pair.avoid, pair.use).map((at) => ({ sentence, at, pair }))),
+  );
+  if (hits.length === 0 || hits.length < options.limit) return [];
+  return hits.map((hit) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: hit.sentence.text.trim(),
+    values: { matched: hit.pair.avoid, preferred: hit.pair.use, count: hits.length, limit: options.limit, offset: hit.sentence.span.start + hit.at },
+  }));
+};
+
+const KIND_NAME: Readonly<Record<SpacingKind, string>> = { letter: "英字", "before-digit": "後ろの数字", "after-digit": "前の数字" };
+const KINDS: readonly SpacingKind[] = ["letter", "before-digit", "after-digit"];
+
+type Located = { readonly sentence: Sentence; readonly offset: number; readonly kind: SpacingKind; readonly spaced: boolean };
+
+/**
+ * 日本語と英字・数字のあいだを、空けるか詰めるか。文書の中で混ざっていたら、少ないほうを指摘する。
+ * どちらが正しいかは決めない。決めるのはチームで、chaff はそろっているかだけを見る。
+ */
+export const latinSpacing: Detector = (doc, options): Finding[] => {
+  const located: Located[] = doc.sentences.flatMap((sentence) => latinBoundaries(sentence.text).map((boundary) => ({ sentence, ...boundary })));
+  return KINDS.flatMap((kind) => {
+    const ofKind = located.filter((entry) => entry.kind === kind);
+    const minority = minorityStyle(ofKind);
+    if (minority === undefined) return [];
+    const odd = ofKind.filter((entry) => entry.spaced === minority);
+    if (odd.length < options.limit) return [];
+    return odd.map((entry) => ({
+      rule: "",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: entry.sentence.text.trim(),
+      values: {
+        kind: KIND_NAME[kind],
+        style: minority ? "空けています" : "詰めています",
+        usual: minority ? "詰める" : "空ける",
+        count: odd.length,
+        of: ofKind.length,
+        limit: options.limit,
+        offset: entry.sentence.span.start + entry.offset,
+      },
+    }));
+  });
+};

package/src/detectors/structure-tree.ts

@@ -0,0 +1,32 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { danglingReferences, duplicateDefinitions, type StructureIssue } from "../structure/issues.ts";
+import { numberingBreaks } from "../structure/numbering.ts";
+
+const QUOTE_LENGTH = 80;
+
+/** 指摘の位置から行末までを引用する。条の見出しや参照を含む一行が、読み手の探す手がかりになる。 */
+const quoteAt = (source: string, offset: number): string => {
+  const end = source.indexOf("\n", offset);
+  return source
+    .slice(offset, end === -1 ? source.length : end)
+    .slice(0, QUOTE_LENGTH)
+    .trim();
+};
+
+const findingsOf =
+  (rule: string, issuesOf: (tree: NonNullable<ProseDocument["structure"]>) => StructureIssue[]): Detector =>
+  (doc): Finding[] =>
+    doc.structure === undefined
+      ? []
+      : issuesOf(doc.structure).map((issue) => ({
+          rule,
+          severity: "error",
+          line: 0,
+          column: 0,
+          quote: quoteAt(doc.source, issue.offset),
+          values: { ...issue.values, offset: issue.offset },
+        }));
+
+export const danglingReference: Detector = findingsOf("dangling-reference", danglingReferences);
+export const numberingGap: Detector = findingsOf("numbering-gap", numberingBreaks);
+export const duplicateDefinition: Detector = findingsOf("duplicate-definition", duplicateDefinitions);

package/src/document.ts

@@ -3,8 +3,11 @@ import { gfmTable } from "micromark-extension-gfm-table";
 import { gfmTableFromMarkdown } from "mdast-util-gfm-table";
 import { frontmatter } from "micromark-extension-frontmatter";
 import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
+import { atxHeadingText, headingText } from "./heading-text.ts";
 import { maskSpans } from "./mask.ts";
-import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span } from "./plugin.ts";
+import { buildTree, NO_OUTLINE, type Outline } from "./structure/build.ts";
+import { isMarkdownPath } from "./structure/markdown-path.ts";
+import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode } from "./plugin.ts";
 
 type Place = { readonly offset?: number | undefined };
 type Node = {
@@ -120,7 +123,7 @@ const textOf = (node: Node, source: string): string => {
   return parts.join("");
 };
 
-type Heading = { readonly depth: number; readonly text: string; readonly start: number; readonly end: number };
+export type Heading = { readonly depth: number; readonly text: string; readonly start: number; readonly end: number };
 
 const headingsOf = (root: Node, source: string): Heading[] => {
   const found: Heading[] = [];
@@ -128,7 +131,10 @@ const headingsOf = (root: Node, source: string): Heading[] => {
     if (node.type !== "heading") return;
     const span = spanOf(node);
     const depth = typeof node === "object" && "depth" in node && typeof node.depth === "number" ? node.depth : 1;
-    if (span !== undefined) found.push({ depth, text: textOf(node, source).trim(), start: span.start, end: span.end });
+    if (span === undefined) return;
+    // ATX（行頭が #）なら閉じの # も外す。setext の見出しの末尾の # は言葉なので残す。
+    const read = source.startsWith("#", span.start) ? atxHeadingText : headingText;
+    found.push({ depth, text: read(textOf(node, source)), start: span.start, end: span.end });
   });
   return found;
 };
@@ -227,13 +233,23 @@ const listsOf = (root: Node, source: string): BulletList[] => {
 };
 
 /** チームが chaff.yaml に書いたもの。語彙表と同じ器に入れて、detector には出所を見せない。 */
-export type TeamRules = { readonly jargon: readonly string[]; readonly requiredSections: readonly string[] };
+export type TeamRules = {
+  readonly jargon: readonly string[];
+  readonly requiredSections: readonly string[];
+  /** { 使わない書き方: 使う書き方 }。preferred-term が語彙表として読む。 */
+  readonly prefer?: Readonly<Record<string, string>>;
+};
 
 const EMPTY_TEAM: TeamRules = { jargon: [], requiredSections: [] };
 
 /** Config から取り出す。document は Config の形を知らない。 */
-export const teamRules = (config: { readonly jargon: readonly string[]; readonly requiredSections: readonly string[] }): TeamRules => ({
+export const teamRules = (config: {
+  readonly jargon: readonly string[];
+  readonly requiredSections: readonly string[];
+  readonly prefer?: Readonly<Record<string, string>>;
+}): TeamRules => ({
   jargon: config.jargon,
+  prefer: config.prefer ?? {},
   requiredSections: config.requiredSections,
 });
 
@@ -247,6 +263,9 @@ export const buildDocument = (path: string, source: string, adapter: LanguageAda
   const paragraphSpans = spansOfType(root, "paragraph");
   const listItems = spansOfType(root, "listItem");
   const sentences = sentencesOf(prose, paragraphSpans, adapter);
+  const patterns = adapter.structure;
+  // null は「作ったが構造を読めない言語だった」、undefined は「まだ作っていない」。
+  const tree: { value: StructureNode | null | undefined } = { value: undefined };
   return {
     path,
     source,
@@ -258,7 +277,31 @@ export const buildDocument = (path: string, source: string, adapter: LanguageAda
     listSpans: listItems,
     paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
     lists: listsOf(root, source),
-    lexicons: { ...adapter.lexicons, "internal-jargon": team.jargon.map((pattern) => ({ pattern })) },
+    lexicons: {
+      ...adapter.lexicons,
+      "internal-jargon": team.jargon.map((pattern) => ({ pattern })),
+      // 使わない書き方を pattern に、使う書き方を instead_of に置く。語彙表の「同じことの別の書き方」と同じ向き。
+      "preferred-term": Object.entries(team.prefer ?? {}).map(([pattern, use]) => ({ pattern, instead_of: use })),
+    },
     requiredSections: team.requiredSections,
+    // 構造の rule（参照先が無い・番号の抜け）が読む木。どの rule も読まなければ作らない。何万行の契約書で、他の rule の lint に代金を払わせない。
+    get structure(): StructureNode | undefined {
+      tree.value ??=
+        patterns === undefined
+          ? null
+          : buildTree({ path, source, language: adapter.id, outline: isMarkdownPath(path) ? outlineOf(root, source) : NO_OUTLINE }, patterns);
+      return tree.value ?? undefined;
+    },
   };
 };
+
+/** 番号を探してはいけない範囲。コードの中の「第3条」は条ではなく、参照でもない。 */
+const OPAQUE = ["code", "inlineCode", "html", "yaml", "toml"];
+
+const outlineOf = (root: Node, source: string): Outline => ({
+  headings: headingsOf(root, source),
+  opaque: OPAQUE.flatMap((type) => spansOfType(root, type)),
+});
+
+/** 構造を読むための Markdown の手がかり。見出しと、中を読まない範囲。 */
+export const markdownOutline = (source: string): Outline => outlineOf(parse(source), source);

package/src/eval.ts

@@ -35,11 +35,12 @@ const stricterIsHigher = (rule: RuleDefinition): boolean => (rule.levels.strict
 const MULTIPLIERS = [0.5, 0.7, 0.85, 1, 1.25, 1.5, 2, 3];
 
 /** rule 自身が持つ段を基点に掃引する。rule ごとに単位が違うので、倍率で散らす。 */
-const candidates = (rule: RuleDefinition): number[] => {
+const candidates = (rule: RuleDefinition, current: number): number[] => {
   const base = rule.levels.normal ?? 1;
   const fromLevels = [rule.levels.strict, rule.levels.normal, rule.levels.relaxed].filter((value) => value !== undefined);
   const scaled = MULTIPLIERS.map((factor) => Math.max(1, Math.round(base * factor)));
-  return [...new Set([...fromLevels, ...scaled])].sort((left, right) => left - right);
+  // 数値で決めた上限は、段の表に無くても掃引に入れる。入れないと「現在」の行が出ない。
+  return [...new Set([...fromLevels, ...scaled, current])].sort((left, right) => left - right);
 };
 
 const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number): Point => {
@@ -63,6 +64,16 @@ const recommend = (rule: RuleDefinition, sweep: readonly Point[], total: number)
   return strictest;
 };
 
+/** lint と同じ要求の読み方。知らない要求は満たさないものとする。pos に読み替えると、動かない rule を測ってしまう。 */
+const meets = (need: string, docs: readonly ProseDocument[]): boolean => {
+  const capabilities = docs[0]?.capabilities;
+  if (need === "pos") return capabilities?.pos === true;
+  if (need === "lemma") return capabilities?.lemma === true;
+  // 木は adapter が structure を持つときだけ作れる。無いまま測ると、どの閾値でも 0 件になる。
+  if (need === "structure") return docs.length > 0 && docs.every((doc) => doc.structure !== undefined);
+  return false;
+};
+
 /**
  * lint で動かない rule は掃引しない。
  * 動かないものの閾値を測ると、「どの閾値でも 0 件」が「よく校正されている」に見える。
@@ -71,16 +82,25 @@ const measurable = (rule: RuleDefinition, docs: readonly ProseDocument[], genre:
   if (rule.layer === "L4" || !rule.use_for.some((target) => genre.startsWith(target))) return false;
   if (rule.languages !== undefined && !rule.languages.includes(language)) return false;
   if (rule.from.length > 0) return false;
-  const capabilities = docs[0]?.capabilities;
-  return !rule.requires.some((need) => (need === "lemma" ? capabilities?.lemma : capabilities?.pos) !== true);
+  return rule.requires.every((need) => meets(need, docs));
 };
 
-export const evaluate = (docs: readonly ProseDocument[], rules: readonly RuleDefinition[], genre: string, language: string): RuleReport[] =>
+/**
+ * limits は chaff.yaml に数値で書いた上限。書いてあれば、それが lint で効いている「現在」の値。
+ * 段の言葉（relaxed など）で書いた設定は、これまでどおり normal の値を「現在」とする。
+ */
+export const evaluate = (
+  docs: readonly ProseDocument[],
+  rules: readonly RuleDefinition[],
+  genre: string,
+  language: string,
+  limits: Readonly<Record<string, number>> = {},
+): RuleReport[] =>
   rules
     .filter((rule) => measurable(rule, docs, genre, language))
     .map((rule) => {
-      const sweep = candidates(rule).map((limit) => countAt(docs, rule, limit));
-      const current = rule.levels.normal ?? 1;
+      const current = limits[rule.id] ?? rule.levels.normal ?? 1;
+      const sweep = candidates(rule, current).map((limit) => countAt(docs, rule, limit));
       return {
         rule: rule.id,
         name: rule.name[language] ?? rule.id,

package/src/heading-text.ts

@@ -0,0 +1,26 @@
+/**
+ * 見出しの末尾に付けた属性を外した、見出しの言葉。`## ステップ 1 {#step1}` は「ステップ 1」。
+ * kramdown（`{#id}`、`{: .class}`）と pandoc（`{#id .class}`）の書き方。属性は読者に見えないので、
+ * 残すと見出しの言い直しや番号の読み取りが、見えない文字に引きずられる。
+ * 波括弧で終わっていても、中身が `#` `.` `:` で始まらないもの（`## {name} の設定`）は言葉のうち。
+ */
+export const headingText = (raw: string): string => {
+  const trimmed = raw.trim();
+  if (!trimmed.endsWith("}")) return trimmed;
+  const open = trimmed.lastIndexOf("{");
+  if (open === -1) return trimmed;
+  const inner = trimmed.slice(open + 1, -1).trimStart();
+  const isAttributes = inner.startsWith("#") || inner.startsWith(".") || inner.startsWith(":");
+  return isAttributes ? trimmed.slice(0, open).trim() : trimmed;
+};
+
+/**
+ * ATX 見出し（`## 見出し ##`）の言葉。属性を外してから、閉じの `#` を外す。
+ * `## Install ## {#install}` は閉じの `#` の後ろに属性があるので、この順でないと `##` が言葉に残る。
+ * 下線で書く見出し（setext）には使わない。そちらの末尾の `##` は本当に言葉の一部。
+ */
+export const atxHeadingText = (content: string): string => {
+  const withoutAttributes = headingText(content);
+  const closing = withoutAttributes.search(/(?:^|[ \t])#+$/u);
+  return (closing === -1 ? withoutAttributes : withoutAttributes.slice(0, closing)).trim();
+};

package/src/orthography.ts

@@ -0,0 +1,115 @@
+// 表記のそろい。書き方の決まりのうち、文字だけで決まるもの。
+
+const escapeRegExp = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/** text の中で word が現れる [始まり, 終わり) を、左から順に。大文字小文字を区別しないときは i で探す（位置は元の文字列のまま）。 */
+const spansOf = (text: string, word: string, ignoreCase: boolean): [number, number][] => {
+  const pattern = new RegExp(escapeRegExp(word), ignoreCase ? "giu" : "gu");
+  const found: [number, number][] = [];
+  for (let match = pattern.exec(text); match !== null; match = pattern.exec(text)) {
+    found.push([match.index, match.index + match[0].length]);
+    // 重なって現れるものも拾う。次は 1 つ先から探す。
+    pattern.lastIndex = match.index + 1;
+  }
+  return found;
+};
+
+/**
+ * avoid が現れる位置のうち、use の一部として現れたものを除いたもの。
+ * 「ユーザ」を避けて「ユーザー」と書く決まりのとき、「ユーザー」の中の「ユーザ」は指摘しない。
+ * 大文字小文字は区別しない（文頭の「E-mail」も「e-mail」）。ただし二つが大文字小文字だけ違う組
+ * （「Javascript」→「JavaScript」）は、それ自体が大文字小文字の決まりなので区別して探す。
+ */
+export const occurrencesOutside = (text: string, avoid: string, use: string): number[] => {
+  if (avoid === "") return [];
+  const ignoreCase = avoid.toLowerCase() !== use.toLowerCase();
+  const covered = use === "" ? [] : spansOf(text, use, ignoreCase);
+  const found: number[] = [];
+  // covered は始まりの順に並ぶ。始まりが at 以前のものの終わりの最大が end 以上なら、どれかに収まっている。
+  let next = 0;
+  let reach = -1;
+  let at = 0;
+  for (const [start, end] of spansOf(text, avoid, ignoreCase)) {
+    if (start < at) continue;
+    while (next < covered.length && (covered[next]?.[0] ?? Infinity) <= start) {
+      reach = Math.max(reach, covered[next]?.[1] ?? -1);
+      next += 1;
+    }
+    if (reach < end) found.push(start);
+    at = end;
+  }
+  return found;
+};
+
+export type SpacingKind = "letter" | "before-digit" | "after-digit";
+export type Boundary = { readonly offset: number; readonly kind: SpacingKind; readonly spaced: boolean };
+
+const JAPANESE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー]/u;
+const LETTER = /[A-Za-z]/u;
+const DIGIT = /\d/u;
+
+/** Latin 側の字の種類。digitSide は、その数字が日本語の右（前に日本語）か左（後ろに日本語）か。 */
+const kindOf = (char: string | undefined, digitSide: "before-digit" | "after-digit"): SpacingKind | undefined => {
+  if (char === undefined) return undefined;
+  if (LETTER.test(char)) return "letter";
+  return DIGIT.test(char) ? digitSide : undefined;
+};
+
+const isJapanese = (char: string | undefined): boolean => char !== undefined && JAPANESE.test(char);
+
+/** japanese が日本語の字のとき、other の英字・数字の種類。 */
+const latinBeside = (japanese: string | undefined, other: string | undefined, digitSide: "before-digit" | "after-digit"): SpacingKind | undefined =>
+  isJapanese(japanese) ? kindOf(other, digitSide) : undefined;
+
+/** 日本語の字の隣にある英字・数字との境目。間が半角空白 1 つなら「空けている」、何も無ければ「詰めている」。 */
+const ALPHANUMERIC = /[A-Za-z0-9.]/u;
+
+/**
+ * 日本語の左にある英数字の並びの、先頭の字。「3GBの」の「GB」は数量の単位で、並びは数字で始まる。
+ * そうした並びと日本語の境目は、英字の空け方ではなく数字の後ろの空け方として数える（「3回」と同じ）。
+ */
+const runStart = (chars: readonly string[], last: number): string | undefined => {
+  let first = last;
+  while (first > 0 && ALPHANUMERIC.test(chars[first - 1] ?? "")) first -= 1;
+  return chars[first];
+};
+
+/** 左の並びの種類。数字で始まる並び（3GB、10ms）は数字として扱う。 */
+const leftRunBeside = (chars: readonly string[], last: number, japanese: string | undefined): SpacingKind | undefined => {
+  const kind = latinBeside(japanese, chars[last], "after-digit");
+  return kind === "letter" && DIGIT.test(runStart(chars, last) ?? "") ? "after-digit" : kind;
+};
+
+const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "offset"> | undefined => {
+  const [left, right, after] = [chars[index], chars[index + 1], chars[index + 2]];
+  const touching = latinBeside(left, right, "before-digit") ?? leftRunBeside(chars, index, right);
+  if (touching !== undefined) return { kind: touching, spaced: false };
+  if (right !== " ") return undefined;
+  const spaced = latinBeside(left, after, "before-digit") ?? leftRunBeside(chars, index, after);
+  return spaced === undefined ? undefined : { kind: spaced, spaced: true };
+};
+
+/** 文の中の境目を全部。offset は境目の位置（左の字の直後、UTF-16）。配列を作り直さずに一度なめる。 */
+export const latinBoundaries = (text: string): Boundary[] => {
+  const chars = [...text];
+  const found: Boundary[] = [];
+  let offset = 0;
+  chars.forEach((char, index) => {
+    offset += char.length;
+    const boundary = boundaryAt(chars, index);
+    if (boundary !== undefined) found.push({ ...boundary, offset });
+  });
+  return found;
+};
+
+/**
+ * 混ざっているとき、そろえるべき少数派。種類（英字・数字の前・数字の後ろ）ごとに数える。
+ * 同数なら、文書が先に使った書き方をその文書の書き方とみなし、後から出た書き方を少数派にする。
+ */
+export const minorityStyle = (boundaries: readonly Boundary[]): boolean | undefined => {
+  const spaced = boundaries.filter((boundary) => boundary.spaced).length;
+  const touching = boundaries.length - spaced;
+  if (spaced === 0 || touching === 0) return undefined;
+  if (spaced !== touching) return spaced < touching;
+  return !(boundaries[0]?.spaced ?? false);
+};

package/src/plugin.ts

@@ -71,6 +71,79 @@ export type LanguageAdapter = {
   readonly segment: (text: string) => Segmentation;
   /** L2 rule が word_list で引く。アダプタが自分の言語のぶんだけを持つ。 */
   readonly lexicons: Readonly<Record<string, Lexicon>>;
+  /** 文書の構造を読む型。無い言語では `chaff tree` がそう言って止まる。 */
+  readonly structure?: StructurePatterns;
+};
+
+// ───────── 文書の構造 ─────────
+
+/**
+ * 行頭の番号 1 つ。「第3条」「２」「(a)」を読むのは言語パッケージで、
+ * 入れ子と番地を決めるのは core。core は番号の書き方を知らない。
+ */
+export type NumberedLine = {
+  readonly kind: "chapter" | "article" | "item";
+  /** 入れ子の深さ。条が 1、項が 2、号が 3 のように、言語パッケージが決める。条より外の編・章・節は 0 以下。 */
+  readonly depth: number;
+  /** 番地の部品。"3"、"4.2"、"a"。 */
+  readonly number: string;
+  /** true なら number だけで番地が決まる（条番号、4.2 のような通し番号）。false なら親の番地に続ける。 */
+  readonly absolute: boolean;
+  /** 書かれたままの番号。「第3条」「Section 4.2」。 */
+  readonly label: string;
+  /** 番号に続く見出し。「第3条（支払）」の「支払」。本文しか無ければ空。 */
+  readonly heading: string;
+  /** 番号の後ろの文字列全部。定義や参照はここから探す。 */
+  readonly rest: string;
+  /**
+   * 並びの中の位置。第三条は 3、(ii) は 2、(b) は 2、4.2 は 2。番号の抜けを見る rule が比べる。
+   * 枝番号（第3条の2）は並びの外なので付けない。読み方を知っているのは言語パッケージだけなので、core は計算しない。
+   */
+  readonly ordinal?: number | undefined;
+};
+
+/** 番号を読むときに見える周り。「(i)」がローマ数字か英字かは、開いている番号で決まる。 */
+export type NumberingContext = {
+  readonly open: readonly NumberedLine[];
+  /** Markdown の見出しの行か。本文の「1. 」は箇条書きで、見出しの「1. 」は章番号。 */
+  readonly isHeading: boolean;
+};
+
+/** 行の中で見つけたもの。start / end は渡した文字列の中の位置。 */
+export type Mention = { readonly start: number; readonly end: number; readonly attrs: Readonly<Record<string, string | number>> };
+
+export type StructurePatterns = {
+  readonly numbered: (line: string, context: NumberingContext) => NumberedLine | undefined;
+  /** 定義。attrs.term に定義された語。 */
+  readonly definitions: (text: string) => readonly Mention[];
+  /** 参照。attrs.target に正規化した番地（"12.1"）、attrs.label に書かれたまま。 */
+  readonly references: (text: string) => readonly Mention[];
+  /** 義務・禁止・許可。attrs.marker に語、attrs.type に must / must-not / may。 */
+  readonly obligations: (text: string) => readonly Mention[];
+  /** 数量。attrs.value に数、attrs.unit に単位。 */
+  readonly quantities: (text: string) => readonly Mention[];
+  /** 日付。attrs.value に "2024-04-01"・"2024-04"・"04-01"・"2024" のどれか。無い言語は日付を読まない。 */
+  readonly dates?: (text: string) => readonly Mention[];
+  /**
+   * 「1.5 倍」「2.5 days」の 1.5 は通し番号ではない。番号と後ろの文字列を渡し、後ろが単位なら true。
+   * 数字と点だけの通し番号は core が言語を問わず読むので、それを数量と見分けられるのは言語パッケージだけ。
+   */
+  readonly countedAfter?: (number: string, rest: string) => boolean;
+};
+
+export type StructureKind = "doc" | "section" | "chapter" | "article" | "item" | "definition" | "reference" | "obligation" | "quantity" | "date";
+
+/** 番地の付いた木の節点。すべて元の文書の位置（UTF-16）と行を持つ。 */
+export type StructureNode = {
+  readonly kind: StructureKind;
+  /** 節・条・項の番地。"3.2"、見出しは "h2.1"。定義や参照のような葉は空。 */
+  readonly address: string;
+  readonly span: Span;
+  readonly line: number;
+  readonly attrs: Readonly<Record<string, string | number>>;
+  readonly children: readonly StructureNode[];
+  /** 番号付きのまとまりの、並びの中の位置（NumberedLine.ordinal）。S 式には出さない。 */
+  readonly ordinal?: number;
 };
 
 // ───────── 文書モデルと rule ─────────
@@ -115,6 +188,8 @@ export type ProseDocument = {
   readonly lexicons: Readonly<Record<string, Lexicon>>;
   /** この種類の文書に無いと困る見出し。チームが chaff.yaml で決める。 */
   readonly requiredSections: readonly string[];
+  /** 番地の付いた木（§27）。adapter が structure を持たない言語では無い。 */
+  readonly structure: StructureNode | undefined;
 };
 
 export type Severity = "error" | "warning" | "info";

package/src/position.ts

@@ -12,7 +12,27 @@ export const lineStarts = (source: string): number[] => {
   return starts;
 };
 
+/**
+ * offset を含む行。starts は昇順なので二分探索で引く。指摘が何千もある長い文書で、指摘ごとに全行をなめない。
+ * offset より前に行頭が無ければ（負の値、NaN）先頭の行とする。
+ */
+const lineIndexOf = (starts: readonly number[], offset: number): number => {
+  let low = 0;
+  let high = starts.length - 1;
+  let found = 0;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    if ((starts[middle] ?? Number.POSITIVE_INFINITY) <= offset) {
+      found = middle;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return found;
+};
+
 export const placeOf = (starts: readonly number[], offset: number): Place => {
-  const index = starts.reduce((best, start, at) => (start <= offset ? at : best), 0);
+  const index = lineIndexOf(starts, offset);
   return { line: index + 1, column: offset - (starts[index] ?? 0) + 1 };
 };

package/src/render/rules-json.ts

@@ -5,6 +5,8 @@ import type { RuleDefinition } from "../plugin.ts";
 const now = (rule: RuleDefinition, config: Config, genre: string): Record<string, unknown> => {
   const explicit = config.rules[rule.id];
   if (explicit === "off") return { level: "off", why_off: "設定で止めている" };
+  const limit = rule.layer === "L4" ? undefined : config.limits[rule.id];
+  if (limit !== undefined) return { level: "normal", limit, set_as: "number" };
   if (explicit !== undefined) return { level: explicit, limit: resolve(rule, explicit, genre).limit };
   if (rule.status === "experimental" && !config.experimental) {
     return { level: "off", why_off: "experimental な rule は既定で動かさない", turn_on_with: `npx chaff lint --experimental` };
@@ -12,6 +14,13 @@ const now = (rule: RuleDefinition, config: Config, genre: string): Record<string
   return { level: "normal", limit: resolve(rule, "normal", genre).limit };
 };
 
+const yourSetting = (rule: RuleDefinition, config: Config): Record<string, unknown> | null => {
+  const level = config.rules[rule.id];
+  if (level === undefined) return null;
+  const limit = rule.layer === "L4" ? undefined : config.limits[rule.id];
+  return limit === undefined ? { level, from: config.path } : { level, limit, from: config.path };
+};
+
 /** ジャンルで数字が変わる rule があるので、いま効いている表と既定の表の両方を出す。 */
 const levelsOf = (rule: RuleDefinition, genre: string): Record<string, unknown> => {
   const effective = Object.fromEntries(
@@ -42,7 +51,7 @@ export const rulesJson = (rules: readonly RuleDefinition[], config: Config, lang
         use_for: rule.use_for,
         ...levelsOf(rule, genre),
         levels_you_can_set: definedLevels(rule),
-        your_setting: config.rules[rule.id] === undefined ? null : { level: config.rules[rule.id], from: config.path },
+        your_setting: yourSetting(rule, config),
         now: now(rule, config, genre),
       })),
       how_to_change: {

package/src/run.ts

@@ -43,9 +43,9 @@ const hasTokens = (doc: ProseDocument): boolean => doc.sentences.length === 0 ||
 /** 要求を満たさない rule は動かせない。満たさないまま動かすと「指摘 0 件」が保証に見える。 */
 const unmet = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
   if (rule.languages !== undefined && !rule.languages.includes(doc.language)) return `${doc.language} 向けの rule ではないため`;
-  const missing = rule.requires.find((need) => !has(doc.capabilities, need));
+  const missing = rule.requires.filter((need) => need !== "structure").find((need) => !has(doc.capabilities, need));
   if (missing !== undefined) return `この言語では${CAPABILITY_NAME[missing] ?? missing}が使えないため`;
-  if (rule.requires.length > 0 && !hasTokens(doc)) return "アダプタが品詞を返さなかったため";
+  if (rule.requires.some((need) => need === "pos" || need === "lemma") && !hasTokens(doc)) return "アダプタが品詞を返さなかったため";
   return undefined;
 };
 
@@ -92,7 +92,19 @@ const compositeOf = (rule: RuleDefinition, found: readonly Finding[], limit: num
   ];
 };
 
-export const runRules = (doc: ProseDocument, rules: readonly RuleDefinition[], settings: Settings, experimental: boolean, genre: string): RunResult => {
+/** chaff.yaml の rules に数値で書いた上限。段階の表より先に効く。 */
+export type Limits = Readonly<Record<string, number>>;
+
+const limitFor = (rule: RuleDefinition, level: Level, genre: string, limits: Limits): number => limits[rule.id] ?? resolve(rule, level, genre).limit;
+
+export const runRules = (
+  doc: ProseDocument,
+  rules: readonly RuleDefinition[],
+  settings: Settings,
+  experimental: boolean,
+  genre: string,
+  limits: Limits = {},
+): RunResult => {
   const starts = lineStarts(doc.source);
   const applicable = forGenre(rules, genre);
   const forced = applicable
@@ -111,12 +123,17 @@ export const runRules = (doc: ProseDocument, rules: readonly RuleDefinition[], s
         const why = rule.status === "experimental" && settings[rule.id] === undefined ? "まだ試験中のため" : "設定で止めているため";
         return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why }] };
       }
+      // 木は capability ではなく、adapter が structure を持つかで決まる。持たない言語で動かすと「参照先が無い」が 0 件に見える。
+      // 段階を見た後で聞く。doc.structure は触れたときに木を作るので、止めている rule のために作らない。
+      if (rule.requires.includes("structure") && doc.structure === undefined) {
+        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: `${doc.language} のパッケージは文書の構造を読めないため` }] };
+      }
       // 複合シグナルは二段目で扱う。一段目では「検出器が無い」と言わせない。
       if (rule.from.length > 0) return acc;
       const detector = DETECTORS[rule.how_to_find];
       if (detector === undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: `検出器 ${rule.how_to_find} がないため` }] };
       const options = {
-        limit: resolve(rule, level, genre).limit,
+        limit: limitFor(rule, level, genre, limits),
         lexicon: rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list],
         where: rule.where,
       };
@@ -131,7 +148,7 @@ export const runRules = (doc: ProseDocument, rules: readonly RuleDefinition[], s
   );
   const composites = applicable
     .filter((rule) => rule.from.length > 0 && levelFor(rule, settings, experimental) !== "off")
-    .flatMap((rule) => compositeOf(rule, outcome.findings, resolve(rule, levelFor(rule, settings, experimental), genre).limit, starts));
+    .flatMap((rule) => compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental), genre, limits), starts));
   const all = [...outcome.findings, ...composites];
   return { ...outcome, findings: [...all].sort((left, right) => left.line - right.line), forcedExperimental: forced };
 };