chaffjs 0.14.0 → 0.16.0

package/src/genre-parse.ts

@@ -0,0 +1,126 @@
+import { isLevel } from "./levels.ts";
+import type { Level, Localized } from "./plugin.ts";
+
+/** A preset's rules: the level each named rule runs at, under whatever chaff.yaml's rules say. */
+export type PresetLevels = Readonly<Record<string, Level>>;
+
+/** A group of genres (legal, literature): its name, and the levels every genre in it shares. */
+export type GenreGroup = { readonly id: string; readonly name: Localized; readonly rules: PresetLevels };
+
+/** One genre of genres.yaml: what it is for, the levels it sets on top of its group's, and the profile it reads with. */
+export type GenreDefinition = {
+  readonly id: string;
+  readonly name: Localized;
+  readonly summary: Localized;
+  readonly rules: PresetLevels;
+  readonly profile: string | undefined;
+  readonly suggest: GenreSuggest;
+};
+
+/** A line shape that marks the genre, and how many lines must have it. */
+type LineCue = { readonly line: RegExp; readonly minLines: number };
+
+/** What makes a document look like this genre when no genre is set: its path, or enough lines of the genre's own shape, per language. */
+export type GenreSuggest = { readonly paths: readonly RegExp[]; readonly lines: Readonly<Record<string, LineCue>> };
+
+export type GenreData = { readonly groups: readonly GenreGroup[]; readonly genres: readonly GenreDefinition[] };
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isLocalized = (value: unknown): value is Localized =>
+  isRecord(value) && typeof value["ja"] === "string" && typeof value["en"] === "string" && value["ja"] !== "" && value["en"] !== "";
+
+const levelsOf = (value: unknown, where: string): PresetLevels => {
+  if (value === undefined) return {};
+  if (!isRecord(value)) throw new Error(`${where}: rules must be a map of rule ids to levels`);
+  const wrong = Object.entries(value).find(([, level]) => !isLevel(level));
+  if (wrong !== undefined) throw new Error(`${where}: ${wrong[0]} has the level ${String(wrong[1])}; use strict, normal, relaxed or off`);
+  return Object.fromEntries(Object.entries(value).filter((entry): entry is [string, Level] => isLevel(entry[1])));
+};
+
+const localizedOf = (value: unknown, field: string, where: string): Localized => {
+  if (!isLocalized(value)) throw new Error(`${where}: ${field} needs a ja and an en text`);
+  return value;
+};
+
+const idOf = (value: unknown, index: number): string => {
+  const id = isRecord(value) ? value["id"] : undefined;
+  if (typeof id !== "string" || id === "") throw new Error(`entry ${String(index + 1)} has no id`);
+  return id;
+};
+
+const groupOf = (value: unknown, index: number): GenreGroup => {
+  const id = idOf(value, index);
+  const raw = isRecord(value) ? value : {};
+  return { id, name: localizedOf(raw["name"], "name", id), rules: levelsOf(raw["rules"], id) };
+};
+
+const patternOf = (value: unknown, flags: string, where: string): RegExp => {
+  if (typeof value !== "string" || value === "") throw new Error(`${where}: a pattern must be a non-empty string`);
+  try {
+    return new RegExp(value, flags);
+  } catch (error) {
+    throw new Error(`${where}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+};
+
+const lineCueOf = (value: unknown, where: string): LineCue => {
+  if (!isRecord(value)) throw new Error(`${where}: needs line and min_lines`);
+  const minLines = value["min_lines"];
+  if (typeof minLines !== "number" || !Number.isInteger(minLines) || minLines < 1) throw new Error(`${where}: min_lines must be a whole number of 1 or more`);
+  return { line: patternOf(value["line"], "u", where), minLines };
+};
+
+const suggestOf = (value: unknown, where: string): GenreSuggest => {
+  if (value === undefined) return { paths: [], lines: {} };
+  if (!isRecord(value)) throw new Error(`${where}: suggest must be a map`);
+  const paths = value["paths"] ?? [];
+  if (!Array.isArray(paths)) throw new Error(`${where}: suggest.paths must be a list`);
+  const lines = Object.entries(value).filter(([key]) => key !== "paths");
+  return {
+    paths: paths.map((path) => patternOf(path, "iu", `${where} suggest.paths`)),
+    lines: Object.fromEntries(lines.map(([language, cue]) => [language, lineCueOf(cue, `${where} suggest.${language}`)])),
+  };
+};
+
+const genreOf = (value: unknown, index: number): GenreDefinition => {
+  const id = idOf(value, index);
+  const raw = isRecord(value) ? value : {};
+  const profile = raw["profile"];
+  if (profile !== undefined && (typeof profile !== "string" || profile === "")) throw new Error(`${id}: profile must be a profile's id`);
+  return {
+    id,
+    name: localizedOf(raw["name"], "name", id),
+    summary: localizedOf(raw["summary"], "summary", id),
+    rules: levelsOf(raw["rules"], id),
+    profile,
+    suggest: suggestOf(raw["suggest"], id),
+  };
+};
+
+const listOf = (raw: Record<string, unknown>, key: string): unknown[] => {
+  const value = raw[key];
+  if (!Array.isArray(value)) throw new Error(`genres.yaml needs a list under ${key}`);
+  return value;
+};
+
+/** genres.yaml as read by the yaml package. Throws on anything it cannot read: the file ships with chaff, so a wrong entry is chaff's bug. */
+export const parseGenres = (raw: unknown): GenreData => {
+  if (!isRecord(raw)) throw new Error("genres.yaml must be a map with groups and genres");
+  const groups = listOf(raw, "groups").map(groupOf);
+  const genres = listOf(raw, "genres").map(genreOf);
+  const orphan = genres.find((genre) => !groups.some((group) => genre.id.startsWith(`${group.id}/`)));
+  if (orphan !== undefined) throw new Error(`${orphan.id}: no group matches the part before its /`);
+  return { groups, genres };
+};
+
+/** The levels a genre's preset sets: its group's, then its own on top. Empty for a genre chaff does not know. */
+export const presetLevelsOf = (data: GenreData, genre: string): PresetLevels => {
+  const own = data.genres.find((entry) => entry.id === genre);
+  if (own === undefined) return {};
+  const group = data.groups.find((entry) => genre.startsWith(`${entry.id}/`));
+  return { ...group?.rules, ...own.rules };
+};
+
+/** The profile a genre reads its documents with, when it names one. */
+export const presetProfileOf = (data: GenreData, genre: string): string | undefined => data.genres.find((entry) => entry.id === genre)?.profile;

package/src/genre-suggest.ts

@@ -0,0 +1,37 @@
+import type { GenreData, GenreDefinition } from "./genre-parse.ts";
+import { detected, type ProfileDefinition } from "./profile/parse.ts";
+
+/** The file a genre is suggested for: where it is, what it says, and its language. */
+export type SuggestInput = { readonly path: string; readonly source: string; readonly language: string };
+
+/** A path cue names the kind outright, so it outweighs any count of lines. */
+const BY_PATH = Number.POSITIVE_INFINITY;
+
+/** How many times over the genre's lines reach their minimum: 1 is just enough, 0 is none of that shape. */
+const linesScore = (genre: GenreDefinition, input: SuggestInput): number => {
+  const cue = genre.suggest.lines[input.language];
+  if (cue === undefined) return 0;
+  return input.source.split("\n").filter((line) => cue.line.test(line)).length / cue.minLines;
+};
+
+/** A genre that reads with a profile has the profile's shape (a statute's article lines) as just-enough evidence. */
+const profileScore = (genre: GenreDefinition, input: SuggestInput, profiles: readonly ProfileDefinition[]): number => {
+  const profile = profiles.find((definition) => definition.id === genre.profile);
+  return profile !== undefined && detected(profile, input.source, input.language) ? 1 : 0;
+};
+
+const scoreOf = (genre: GenreDefinition, input: SuggestInput, profiles: readonly ProfileDefinition[]): number =>
+  genre.suggest.paths.some((pattern) => pattern.test(input.path)) ? BY_PATH : Math.max(linesScore(genre, input), profileScore(genre, input, profiles));
+
+type Scored = { readonly genre: GenreDefinition; readonly score: number };
+
+/**
+ * The genre a file with no genre set looks like, for the screen to suggest. Never used to check the file: switching silently
+ * would change what an existing run reports. The genre whose cues the file meets most strongly wins (a transcript that
+ * discusses a bill has more speaker lines than lines about "this Act"); a tie goes to the genre listed first in genres.yaml.
+ */
+export const suggestGenre = (input: SuggestInput, data: GenreData, profiles: readonly ProfileDefinition[]): GenreDefinition | undefined =>
+  data.genres
+    .map((genre): Scored => ({ genre, score: scoreOf(genre, input, profiles) }))
+    .filter((entry) => entry.score >= 1)
+    .reduce<Scored | undefined>((best, entry) => (best === undefined || entry.score > best.score ? entry : best), undefined)?.genre;

package/src/genre.ts

@@ -1,3 +1,8 @@
+import { loadGenres } from "./genre-load.ts";
+
+/** chaff が知っているジャンル。genres.yaml の並び。rule の use_for はこの頭の部分で当てる。 */
+export const GENRES: readonly string[] = loadGenres().genres.map((genre) => genre.id);
+
 export type GenreGuess = { readonly genre: string; readonly from: "front-matter" | "path" | "content" };
 
 /**
@@ -35,9 +40,24 @@ export const guessGenre = (path: string, source: string, front: string | undefin
   return undefined;
 };
 
-/** front matter の genre / type を拾う。失敗しても落とさない。 */
-export const frontMatterGenre = (source: string): string | undefined => {
-  const match = /^---\n([\s\S]*?)\n---/u.exec(source);
-  const line = match?.[1] === undefined ? undefined : /^(?:genre|type):\s*(\S+)\s*$/mu.exec(match[1]);
-  return line?.[1];
+/** YAML の 1 行の値。行末のコメントと、値を囲む引用符を外す。 */
+const scalarOf = (raw: string): string => {
+  const comment = raw.search(/\s#/u);
+  const value = (comment === -1 ? raw : raw.slice(0, comment)).trim();
+  return /^(["'])(.*)\1$/u.exec(value)?.[2] ?? value;
+};
+
+const valuesOf = (block: string, key: string): string[] => [...block.matchAll(new RegExp(`^${key}:(.*)$`, "gmu"))].map((line) => scalarOf(line[1] ?? ""));
+
+/** front matter の 1 つの欄に書かれた値。front matter が無ければ空。 */
+export const frontMatterValues = (source: string, key: string): string[] => {
+  const block = /^---\n([\s\S]*?)\n---/u.exec(source)?.[1];
+  return block === undefined ? [] : valuesOf(block, key);
 };
+
+/**
+ * front matter の genre / type を拾う。失敗しても落とさない。genre が type より先。
+ * 知っているジャンルだけを返す。Zenn の type（tech / idea）のような別の意味の値をジャンルにすると、どの rule も当てはまらず「指摘なし」になる。
+ */
+export const frontMatterGenre = (source: string): string | undefined =>
+  [...frontMatterValues(source, "genre"), ...frontMatterValues(source, "type")].find((value) => GENRES.includes(value));

package/src/init-choice.ts

@@ -0,0 +1,47 @@
+import type { GenreData } from "./genre-parse.ts";
+import type { Texts, UiLanguage } from "./ui.ts";
+
+/** The genre init writes when nothing is chosen: the one a check uses when none is set. */
+export const DEFAULT_GENRE = "blog/tech";
+
+const TEXT: Texts<{ readonly heading: string; readonly prompt: string; readonly notAGenre: (answer: string) => string; readonly noAnswer: string }> = {
+  ja: {
+    heading: "どの種類の文書をここに置きますか？ 選んだ種類の書き方に合わせて見ます。",
+    prompt: `番号か名前を入れてください（Enter で ${DEFAULT_GENRE}）: `,
+    notAGenre: (answer) => `「${answer}」は一覧にありません。何も作っていません。npx chaffjs init --genre <ジャンル> でも選べます。`,
+    noAnswer: "答えが無いまま入力が終わったので、何も作っていません。",
+  },
+  en: {
+    heading: "What kind of document goes here? chaff checks it the way that kind is written.",
+    prompt: `Type a number or a name (Enter for ${DEFAULT_GENRE}): `,
+    notAGenre: (answer) => `"${answer}" is not in the list. Nothing was created. npx chaffjs init --genre <genre> chooses one too.`,
+    noAnswer: "The input ended without an answer, so nothing was created.",
+  },
+};
+
+/** The numbered list init shows before it asks: every genre with what it is for, in genres.yaml's order. */
+export const genreChoices = (data: GenreData, ui: UiLanguage): string[] => {
+  const width = Math.max(...data.genres.map((genre) => genre.id.length)) + 2;
+  const numberWidth = String(data.genres.length).length;
+  return [
+    "",
+    TEXT[ui].heading,
+    "",
+    ...data.genres.map((genre, index) => `  ${String(index + 1).padStart(numberWidth)}  ${genre.id.padEnd(width)}${genre.summary[ui] ?? ""}`),
+    "",
+  ];
+};
+
+export const choicePrompt = (ui: UiLanguage): string => TEXT[ui].prompt;
+
+export const notAGenre = (answer: string, ui: UiLanguage): string => TEXT[ui].notAGenre(answer);
+
+export const noAnswer = (ui: UiLanguage): string => TEXT[ui].noAnswer;
+
+/** A number from the list, a genre's name, or nothing (the default). undefined for anything else: init then writes nothing. */
+export const genreFromAnswer = (answer: string, ids: readonly string[]): string | undefined => {
+  const typed = answer.trim();
+  if (typed === "") return DEFAULT_GENRE;
+  if (ids.includes(typed)) return typed;
+  return /^\d+$/u.test(typed) ? ids[Number(typed) - 1] : undefined;
+};

package/src/init.ts

@@ -1,9 +1,10 @@
 import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Texts, UiLanguage } from "./ui.ts";
+import { loadGenres } from "./genre-load.ts";
 
 const TEXT: Texts<{
-  readonly config: (genre: string) => string;
+  readonly config: (genre: string, summary: string) => string;
   readonly created: string;
   readonly appended: (lines: readonly string[]) => string;
   readonly configNote: string;
@@ -15,7 +16,7 @@ const TEXT: Texts<{
   readonly nextCheck: string;
 }> = {
   ja: {
-    config: (genre) => `# chaff.yaml — このチームの文章規範
+    config: (genre, summary) => `# chaff.yaml — このチームの文章規範
 #
 # ここに書くのは「既定から変えたもの」だけです。書かなければ既定で動きます。
 # このファイルを消しても chaff は動きます。
@@ -33,9 +34,13 @@ const TEXT: Texts<{
 #   npx chaff explain bold-density        そのルールの意図を読む
 #   npx chaff rules --json                AI に設定を書かせるときに渡す
 
-# この場所に置く文書の種類。
+# この場所に置く文書の種類（${summary}）。ほかの種類: npx chaffjs genres
 genre: ${genre}
 
+# チームが書く固有名詞（組織名・製品名）。1 つの名前として読み、漢字の連なりに数えない。
+# names:
+#   - 個人情報保護委員会
+
 # 既定から変えたものだけを書く。
 rules:
 `,
@@ -50,7 +55,7 @@ rules:
     nextCheck: "  npx chaff .            この場所の Markdown を全部見る",
   },
   en: {
-    config: (genre) => `# chaff.yaml — this team's writing rules
+    config: (genre, summary) => `# chaff.yaml — this team's writing rules
 #
 # Write only what differs from the defaults; anything left out uses the default.
 # chaff still runs if this file is deleted.
@@ -68,9 +73,13 @@ rules:
 #   npx chaff explain bold-density        read what the rule is for
 #   npx chaff rules --json                give this to an AI that writes the settings
 
-# The kind of document kept here.
+# The kind of document kept here (${summary}). The others: npx chaffjs genres
 genre: ${genre}
 
+# The names your team writes (organisations, products). Each is read as one name, not as words to count.
+# names:
+#   - Bank of England
+
 # Only what differs from the defaults.
 rules:
 `,
@@ -108,9 +117,14 @@ const ensureGitignore = (dir: string, text: (typeof TEXT)["ja"]): Written | unde
   return { path, note: text.appended(missing) };
 };
 
+/** What the genre is for, as chaff genres says it; the genre itself when chaff does not know it. */
+const summaryOf = (genre: string, ui: UiLanguage): string => loadGenres().genres.find((entry) => entry.id === genre)?.summary[ui] ?? genre;
+
 export const runInit = (dir: string, genre: string, ui: UiLanguage = "ja"): string[] => {
   const text = TEXT[ui];
-  const made = [writeIfAbsent(join(dir, "chaff.yaml"), text.config(genre), text.configNote), ensureGitignore(dir, text)].filter((entry) => entry !== undefined);
+  const made = [writeIfAbsent(join(dir, "chaff.yaml"), text.config(genre, summaryOf(genre, ui)), text.configNote), ensureGitignore(dir, text)].filter(
+    (entry) => entry !== undefined,
+  );
   if (made.length === 0) return [text.exists];
   return [
     "",
@@ -125,16 +139,3 @@ export const runInit = (dir: string, genre: string, ui: UiLanguage = "ja"): stri
     "",
   ];
 };
-
-export const GENRES: readonly string[] = [
-  "technical/spec",
-  "technical/readme",
-  "blog/tech",
-  "blog/essay",
-  "blog/owned-media",
-  "business/proposal",
-  "business/report",
-  "business/email",
-  "business/press-release",
-  "business/meeting-notes",
-];

package/src/joined-view.ts

@@ -0,0 +1,96 @@
+import { spansWithin, withoutSpans } from "./soft-break.ts";
+import { continuedBreaks, wrapBreaks } from "./line-continues.ts";
+import type { Segmentation, Sentence, Span, Token } from "./plugin.ts";
+
+/**
+ * 消える改行を取り除いた文字列と、その上の範囲を元の文字列の範囲に戻す写像。
+ *
+ * 解析はつないだ文字列で行い、指摘の位置は元の文字列で出す。行・列も、引用して見せる範囲も、元の文書のまま。
+ */
+export type JoinedView = { readonly text: string; readonly toSource: (span: Span) => Span };
+
+type Removed = { readonly at: number; readonly removedBefore: number };
+
+/** 取り除いた各範囲が、つないだ文字列のどこにあったか。removedBefore はそこまでに取り除いた長さ（その範囲を含む）。 */
+const removedPlaces = (breaks: readonly Span[]): Removed[] => {
+  const places: Removed[] = [];
+  breaks.reduce((before, span) => {
+    const removedBefore = before + span.end - span.start;
+    places.push({ at: span.start - before, removedBefore });
+    return removedBefore;
+  }, 0);
+  return places;
+};
+
+/** at が offset 以下（inclusive）または未満の、最後の範囲までに取り除いた長さ。places は at の昇順。 */
+const removedUpTo = (places: readonly Removed[], offset: number, inclusive: boolean): number => {
+  const search = (low: number, high: number, found: number): number => {
+    if (low > high) return found;
+    const middle = (low + high) >> 1;
+    const place = places[middle];
+    if (place === undefined) return found;
+    const reached = inclusive ? place.at <= offset : place.at < offset;
+    return reached ? search(middle + 1, high, place.removedBefore) : search(low, middle - 1, found);
+  };
+  return search(0, places.length - 1, 0);
+};
+
+/**
+ * 始まりは、そこで取り除いた改行の後ろ（次の文字）へ。終わりは、そこで取り除いた改行の手前へ。
+ * 改行をまたぐ語（「関\nする」）は、改行ごと覆う範囲になる。
+ */
+export const joinedView = (text: string, breaks: readonly Span[]): JoinedView => {
+  const places = removedPlaces(breaks);
+  const toSource = (span: Span): Span => {
+    const start = span.start + removedUpTo(places, span.start, true);
+    const end = span.end + removedUpTo(places, span.end, false);
+    return { start, end: Math.max(start, end) };
+  };
+  return { text: withoutSpans(text, breaks), toSource };
+};
+
+const tokenInSource =
+  (view: JoinedView) =>
+  (token: Token): Token => ({ ...token, span: view.toSource(token.span) });
+
+const sentenceInSource =
+  (text: string, view: JoinedView) =>
+  (sentence: Sentence): Sentence => {
+    const span = view.toSource(sentence.span);
+    return {
+      span,
+      text: text.slice(span.start, span.end),
+      ...(sentence.tokens === undefined ? {} : { tokens: sentence.tokens.map(tokenInSource(view)) }),
+    };
+  };
+
+type Segment = (text: string) => Segmentation;
+
+/** breaks を除いて segment し、文と語の範囲を text の上に戻す。文の text は元の文字列の切り出しのまま。 */
+const segmentWithout = (text: string, breaks: readonly Span[], segment: Segment): Sentence[] => {
+  const view = joinedView(text, breaks);
+  return segment(view.text).sentences.map(sentenceInSource(text, view));
+};
+
+const withWrapBreaks = (sentence: Sentence, wrapped: readonly Span[]): Sentence => {
+  const inside = spansWithin(wrapped, sentence.span);
+  return inside.length === 0 ? sentence : { ...sentence, wrapBreaks: inside };
+};
+
+const tokensOf = (sentences: readonly Sentence[]): Token[] => sentences.flatMap((sentence) => sentence.tokens ?? []);
+
+/**
+ * 消える改行を、行が続いていると言えるものだけ除いて segment する。
+ * 一度すべて除いて解析し、その語で決めて、残す改行があれば読み直す。
+ * 語が無ければ（品詞を読まない adapter）決められないので、前と同じく改行ごと渡す。
+ * 除く改行が無ければ segment の結果をそのまま返す。つながない段落の文は、前と同じものになる。
+ */
+export const segmentJoined = (text: string, breaks: readonly Span[], segment: Segment): readonly Sentence[] => {
+  if (breaks.length === 0) return segment(text).sentences;
+  const joined = segmentWithout(text, breaks, segment);
+  const kept = continuedBreaks(breaks, tokensOf(joined));
+  if (kept.length === 0) return segment(text).sentences;
+  const sentences = kept.length === breaks.length ? joined : segmentWithout(text, kept, segment);
+  const wrapped = wrapBreaks(kept, tokensOf(sentences));
+  return sentences.map((sentence) => withWrapBreaks(sentence, wrapped));
+};

package/src/judge.ts

@@ -6,6 +6,7 @@ import * as openai from "./backends/openai.ts";
 import type { AnthropicClient } from "./backends/anthropic.ts";
 import type { OpenAIClient } from "./backends/openai.ts";
 import type { BackendName, Failure, Judge, JsonSchema } from "./backends/types.ts";
+import type { UiLanguage } from "./ui.ts";
 
 export const CACHE_DIR = ".chaff-cache";
 
@@ -87,7 +88,8 @@ export const isAuthFailure = (backend: BackendName, error: unknown): boolean =>
 export const describeFailure = (backend: BackendName, error: unknown): Failure | undefined =>
   backend === "openai" ? openai.describeFailure(error) : anthropic.describeFailure(error);
 
-export const credentialHint = (backend: BackendName): string => (backend === "openai" ? openai.SETUP_HINT : anthropic.SETUP_HINT);
+export const credentialHint = (backend: BackendName, language: UiLanguage): string =>
+  (backend === "openai" ? openai.SETUP_HINT : anthropic.SETUP_HINT)[language];
 
 /**
  * 同じ (model, rule, rubric, candidate) なら 2 度目は問い合わせない。

package/src/line-continues.ts

@@ -0,0 +1,43 @@
+import { firstEndingAfter } from "./soft-break.ts";
+import type { Span, Token } from "./plugin.ts";
+
+/**
+ * 消える改行のうち、どれを消して読むか。決めるのは解析器が読んだ語（全部の改行を消して読んだもの）。
+ *
+ * Markdown の段落は改行を消して表示されるが、書いた人は改行で区切ったつもりのことがある。
+ * 番号だけの見出しの行（「2.1 注文の登録\n登録は」）、宛先や署名を 1 行に 1 つ書いた並び。
+ * そこを消して読むと「登録登録」が語の重なりになる。行が続いていると語で言えるときだけ消す。
+ */
+
+const inside = (token: Token | undefined, part: Span): boolean => token !== undefined && token.span.start < part.start && token.span.end > part.end;
+
+type Around = { readonly across: Token | undefined; readonly before: Token | undefined };
+
+/** 各改行の位置で、改行をまたぐ語（あれば）と、改行の直前で終わる語。tokens は並び順（重ならない）。 */
+const aroundEach = (breaks: readonly Span[], tokens: readonly Token[]): Around[] => {
+  const spans = tokens.map((token) => token.span);
+  return breaks.map((part) => {
+    const at = firstEndingAfter(spans, part.start);
+    return { across: tokens[at], before: tokens[at - 1] };
+  });
+};
+
+/** 解析器が語の途中に置いた改行。語をまたぐなら、行を折り返しただけ。 */
+export const wrapBreaks = (breaks: readonly Span[], tokens: readonly Token[]): Span[] => {
+  const around = aroundEach(breaks, tokens);
+  return breaks.filter((part, index) => inside(around[index]?.across, part));
+};
+
+/** 句を閉じない語。助詞・接続助詞・接続詞で終わる行は、次の行へ続く。 */
+const CONTINUING_POS = new Set(["ADP", "SCONJ", "CCONJ"]);
+/** 読点で終わる行も続く。句点・括弧・名詞で終わる行は、見出しや 1 行 1 項目の終わりと見分けられない。 */
+const COMMAS = new Set(["、", "，"]);
+
+const continuesPast = (token: Token | undefined, part: Span): boolean =>
+  token !== undefined && token.span.end === part.start && (CONTINUING_POS.has(token.pos) || COMMAS.has(token.surface));
+
+/** 行が続いている改行: 語をまたぐものと、句を閉じない語の直後にあるもの。 */
+export const continuedBreaks = (breaks: readonly Span[], tokens: readonly Token[]): Span[] => {
+  const around = aroundEach(breaks, tokens);
+  return breaks.filter((part, index) => inside(around[index]?.across, part) || continuesPast(around[index]?.before, part));
+};

package/src/line-paragraphs.ts

@@ -0,0 +1,83 @@
+import type { Span } from "./plugin.ts";
+
+/**
+ * 1 行に 1 段落を書き、段落の間に空行を置かない文書（青空文庫、議事録、`<br>` で改行した HTML）。
+ * Markdown では全体が 1 つの段落になるが、書いた人にとっては行が段落。
+ *
+ * 割るのは文の終わる改行だけ。文の境目は解析器が改行をつないだ上で決めたもの（#248）なので、折り返した文は割れない。
+ * 形で見分けるのは 2 つ:
+ * - 固定幅の折り返しは、行の多くが文の途中で終わる。文で終わる行（段落の最後の行を含む）が半分に届かなければ割らない
+ *   （議事録は発言者の行と発言の行が交互に来るので、半分ちょうどは割る）。
+ * - 1 行 1 文の書き方（行を意味の切れ目で改める。英語の Markdown に多い）は、段落のつもりではない。
+ *   文の頭で始まり文の終わりで終わる行が 2 文以上を持つことが、段落を 1 行に書いた印。それがたまにしか無ければ割らない。
+ */
+
+/** 2 文以上を持つ行がこれより少なければ、1 行 1 文の書き方にたまに混じる 2 文の行と見分けられない。 */
+const MIN_MULTI_SENTENCE = 3;
+/** 2 文以上を持つ行が、割った段落の数のこの割合に届かなければ割らない。議事録は 1 文の発言が多い。 */
+const MULTI_SENTENCE_SHARE = 1 / 5;
+
+const NEWLINE = /\r?\n/gu;
+
+type Line = { readonly span: Span; readonly newline: number };
+
+/** 段落の中の行と、その行を終える改行の位置（最後の行は段落の終わり）。 */
+const linesOf = (source: string, paragraph: Span): Line[] => {
+  const text = source.slice(paragraph.start, paragraph.end);
+  const breaks = [...text.matchAll(NEWLINE)].map((match) => ({ at: paragraph.start + match.index, width: match[0].length }));
+  const starts = [paragraph.start, ...breaks.map((found) => found.at + found.width)];
+  return starts.map((start, index) => {
+    const end = breaks[index]?.at ?? paragraph.end;
+    return { span: { start, end }, newline: end };
+  });
+};
+
+/** 文の前後の空白を除いた範囲。改行が文の中にあるかを、空白でなく文字で決める。 */
+const coreOf = (source: string, sentence: Span): Span => {
+  const text = source.slice(sentence.start, sentence.end);
+  return { start: sentence.start + text.length - text.trimStart().length, end: sentence.end - (text.length - text.trimEnd().length) };
+};
+
+/** cores（並び順、重ならない）の中で、start が offset 以上の最初の添字。何万行の段落でも行ごとに全部をなめない。 */
+const firstStartingAt = (cores: readonly Span[], offset: number): number => {
+  const search = (low: number, high: number): number => {
+    if (low >= high) return low;
+    const middle = (low + high) >> 1;
+    return (cores[middle]?.start ?? Number.POSITIVE_INFINITY) >= offset ? search(low, middle) : search(middle + 1, high);
+  };
+  return search(0, cores.length);
+};
+
+/** 改行をまたぐ文が無い。またぐなら、改行の直前に始まった文がまだ続いている。 */
+const endsSentence = (line: Line, cores: readonly Span[]): boolean => (cores[firstStartingAt(cores, line.newline) - 1]?.end ?? 0) <= line.newline;
+
+/** 行の並びを、文の終わる改行で区切った段落。 */
+const groupAt = (lines: readonly Line[], closing: readonly boolean[]): Span[] => {
+  const firsts = lines.flatMap((_, index) => (index === 0 || closing[index - 1] === true ? [index] : []));
+  return firsts.map((first, index) => ({
+    start: lines[first]?.span.start ?? 0,
+    end: lines[(firsts[index + 1] ?? lines.length) - 1]?.span.end ?? 0,
+  }));
+};
+
+const sentencesIn = (group: Span, cores: readonly Span[]): number => firstStartingAt(cores, group.end) - firstStartingAt(cores, group.start);
+
+/** 文の頭で始まり文の終わりで終わる行のうち、2 文以上を持つもの。固定幅の折り返しでは、行の両端が偶然そろうことはまれ。 */
+const wholeMultiSentenceLines = (lines: readonly Line[], closing: readonly boolean[], cores: readonly Span[]): number =>
+  lines.filter((line, index) => (index === 0 || closing[index - 1] === true) && closing[index] === true && sentencesIn(line.span, cores) >= 2).length;
+
+/** 行ごとの段落として読む形か。 */
+const isLineShaped = (lines: readonly Line[], closing: readonly boolean[], groups: readonly Span[], cores: readonly Span[]): boolean => {
+  const closed = closing.filter(Boolean).length;
+  const multi = wholeMultiSentenceLines(lines, closing, cores);
+  return closed * 2 >= closing.length && multi >= MIN_MULTI_SENTENCE && multi >= groups.length * MULTI_SENTENCE_SHARE;
+};
+
+/** paragraph を、書いた人が段落のつもりで改めた行ごとに割る。そう読めなければ paragraph 1 つ。sentences は段落の中の文。 */
+export const lineParagraphs = (source: string, paragraph: Span, sentences: readonly Span[]): Span[] => {
+  const lines = linesOf(source, paragraph);
+  const cores = sentences.map((sentence) => coreOf(source, sentence)).filter((core) => core.end > core.start);
+  const closing = lines.map((line) => endsSentence(line, cores));
+  const groups = groupAt(lines, closing);
+  return isLineShaped(lines, closing, groups, cores) ? groups : [paragraph];
+};

package/src/mask.ts

@@ -17,14 +17,13 @@ import type { Span } from "./plugin.ts";
 const blankOut = (text: string): string => text.replace(/[^\n]/gu, (char) => " ".repeat(char.length));
 
 const merge = (spans: readonly Span[]): Span[] =>
-  [...spans]
-    .sort((left, right) => left.start - right.start)
+  spans
+    .toSorted((left, right) => left.start - right.start)
     .reduce<Span[]>((acc, span) => {
       const last = acc.at(-1);
-      if (last !== undefined && span.start <= last.end) {
-        return [...acc.slice(0, -1), { start: last.start, end: Math.max(last.end, span.end) }];
-      }
-      return [...acc, span];
+      if (last !== undefined && span.start <= last.end) acc[acc.length - 1] = { start: last.start, end: Math.max(last.end, span.end) };
+      else acc.push(span);
+      return acc;
     }, []);
 
 export const maskSpans = (source: string, spans: readonly Span[]): string => {

package/src/measure.ts

@@ -1,3 +1,4 @@
+import { withoutSpans } from "./soft-break.ts";
 import type { Sentence } from "./plugin.ts";
 
 /**
@@ -9,7 +10,14 @@ import type { Sentence } from "./plugin.ts";
  *
  * 日本語は文字数、英語は語数。単位は adapter が宣言する。
  */
-export const proseText = (sentence: Sentence): string => sentence.text.replace(/\s+/gu, " ").trim();
+/** 語の途中で折り返した改行（wrapBreaks）は空白にせず除く。「関\nする」を「関 する」と読まない。 */
+export const proseText = (sentence: Sentence): string =>
+  withoutSpans(
+    sentence.text,
+    (sentence.wrapBreaks ?? []).map((span) => ({ start: span.start - sentence.span.start, end: span.end - sentence.span.start })),
+  )
+    .replace(/\s+/gu, " ")
+    .trim();
 
 export const charLength = (sentence: Sentence): number => sentence.text.replace(/\s+/gu, "").length;