@sushichan044/kg-core 0.6.1 → 0.6.3

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import * as v from "valibot";
+import { eastAsianWidth } from "get-east-asian-width";
 //#region src/assert-never.ts
 /**
 * Marks a branch the compiler proved unreachable. Reaching it at runtime means a variant was added
@@ -308,11 +309,38 @@ const ItalicAnnotation = { schema: readonlyObject({
 	kind: v.literal("italic"),
 	range: ManuscriptRange.schema
 }) };
-const RubyAnnotation = { schema: readonlyObject({
+//#endregion
+//#region src/parser/annotation/ruby-annotation.ts
+const GroupRubyKindSchema = v.literal("group");
+const MonoRubyKindSchema = v.literal("mono");
+const JukugoRubyKindSchema = v.literal("jukugo");
+const RubyKindSchema = v.union([
+	GroupRubyKindSchema,
+	MonoRubyKindSchema,
+	JukugoRubyKindSchema
+]);
+const RubyReadingSchema = v.variant("kind", [
+	readonlyObject({
+		kind: GroupRubyKindSchema,
+		text: v.pipe(v.string(), v.nonEmpty())
+	}),
+	readonlyObject({
+		kind: MonoRubyKindSchema,
+		segments: v.pipe(v.array(v.pipe(v.string(), v.nonEmpty())), v.nonEmpty(), v.readonly())
+	}),
+	readonlyObject({
+		kind: JukugoRubyKindSchema,
+		segments: v.pipe(v.array(v.pipe(v.string(), v.nonEmpty())), v.nonEmpty(), v.readonly())
+	})
+]);
+const RubyAnnotationSchema = readonlyObject({
 	kind: v.literal("ruby"),
 	range: ManuscriptRange.schema,
-	reading: v.string()
-}) };
+	reading: RubyReadingSchema
+});
+const RubyKind = { schema: RubyKindSchema };
+const RubyReading = { schema: RubyReadingSchema };
+const RubyAnnotation = { schema: RubyAnnotationSchema };
 const ManuscriptAnnotation = {
 	schema: v.variant("kind", [
 		RubyAnnotation.schema,
@@ -364,12 +392,21 @@ const ParsedManuscriptSchema = readonlyObject({
 function rangeFits(range, manuscript) {
 	return range.source.end <= manuscript.source.length && range.display.end <= manuscript.displayText.length && range.graphemes.end <= manuscript.graphemes.length;
 }
+function hasValidRubyAssociations(manuscript) {
+	const ruby = manuscript.annotations.filter((annotation) => annotation.kind === "ruby");
+	return ruby.every((annotation, index) => {
+		const baseLength = annotation.range.graphemes.end - annotation.range.graphemes.start;
+		if (baseLength <= 0) return false;
+		if (annotation.reading.kind !== "group" && annotation.reading.segments.length !== baseLength) return false;
+		return ruby.slice(index + 1).every((other) => !ManuscriptRange.overlaps(annotation.range, other.range));
+	});
+}
 function isConsistent(manuscript, source) {
 	const joined = manuscript.graphemes.map(({ value }) => value).join("");
 	const sequential = manuscript.graphemes.every(({ range }, index) => range.graphemes.start === index && range.graphemes.end === index + 1 && rangeFits(range, manuscript));
-	return manuscript.source === source && manuscript.displayText === joined && sequential && manuscript.annotations.every(({ range }) => rangeFits(range, manuscript));
+	return manuscript.source === source && manuscript.displayText === joined && sequential && manuscript.annotations.every(({ range }) => rangeFits(range, manuscript)) && hasValidRubyAssociations(manuscript);
 }
-const CONTRACT_MESSAGE = "parser output must contain consistent source, display, grapheme, and annotation ranges";
+const CONTRACT_MESSAGE = "parser output must contain consistent source, display, grapheme, and annotation ranges and valid ruby associations";
 const ParsedManuscript = {
 	schema: ParsedManuscriptSchema,
 	/**
@@ -681,7 +718,10 @@ const kakuyomuParser = {
 					const range = draft.append(source.slice(ruby.parentStart, ruby.parentEnd), ruby.parentStart);
 					draft.annotate({
 						kind: "ruby",
-						reading: ruby.reading,
+						reading: {
+							kind: "group",
+							text: ruby.reading
+						},
 						range: {
 							...range,
 							source: {
@@ -731,7 +771,10 @@ const kakuyomuParser = {
 					const range = draft.append(source.slice(ruby.parentStart, ruby.parentEnd), ruby.parentStart);
 					draft.annotate({
 						kind: "ruby",
-						reading: ruby.reading,
+						reading: {
+							kind: "group",
+							text: ruby.reading
+						},
 						range: {
 							...range,
 							source: {
@@ -797,7 +840,10 @@ function parsePairTag(source, start, prefix) {
 		content,
 		annotation: {
 			kind: "ruby",
-			reading: value.text
+			reading: {
+				kind: "group",
+				text: value.text
+			}
 		}
 	};
 	if ([...graphemeSegmenter.segment(value.text)].length !== 1) return void 0;
@@ -957,35 +1003,48 @@ function composeManuscript(parsed, options) {
 	}, result.warnings);
 }
 //#endregion
-//#region src/composer/grid-settings.ts
-const RANGES = {
-	charsPerLine: {
-		min: 10,
-		max: 60
-	},
-	linesPerStage: {
-		min: 10,
-		max: 60
-	},
-	stagesPerPage: {
-		min: 1,
-		max: 3
-	}
+//#region src/composer/composed-annotation-fragment.ts
+const emLength$1 = () => v.pipe(v.number(), v.finite(), v.minValue(0));
+const continuation = v.union([
+	v.literal("whole"),
+	v.literal("start"),
+	v.literal("middle"),
+	v.literal("end")
+]);
+const PositionedReadingGraphemeSchema = readonlyObject({
+	value: v.string(),
+	offsetEm: v.pipe(v.number(), v.finite()),
+	advanceEm: emLength$1()
+});
+const common$1 = {
+	annotationRange: ManuscriptRange.schema,
+	fragmentRange: ManuscriptRange.schema,
+	continuation
 };
-const boundedCount = (bounds) => v.pipe(v.number(), v.finite(), v.integer(), v.minValue(bounds.min), v.maxValue(bounds.max));
-const GridSettings = {
-	schema: readonlyObject({
-		charsPerLine: boundedCount(RANGES.charsPerLine),
-		linesPerStage: boundedCount(RANGES.linesPerStage),
-		stagesPerPage: boundedCount(RANGES.stagesPerPage)
+const ComposedAnnotationFragment = { schema: v.variant("kind", [
+	readonlyObject({
+		kind: v.literal("bold"),
+		...common$1
 	}),
-	ranges: RANGES,
-	defaults: {
-		charsPerLine: 27,
-		linesPerStage: 23,
-		stagesPerPage: 2
-	}
-};
+	readonlyObject({
+		kind: v.literal("italic"),
+		...common$1
+	}),
+	readonlyObject({
+		kind: v.literal("emphasis"),
+		mark: v.string(),
+		...common$1
+	}),
+	readonlyObject({
+		kind: v.literal("ruby"),
+		rubyKind: RubyKind.schema,
+		reading: v.string(),
+		baseOffsetEm: emLength$1(),
+		baseAdvanceEm: emLength$1(),
+		readingGraphemes: readonlyArray(PositionedReadingGraphemeSchema),
+		...common$1
+	})
+]) };
 const LineOffset = {
 	schema: readonlyObject({
 		leading: nonNegativeInteger(),
@@ -1023,78 +1082,81 @@ const ManuscriptOffsets = {
 	/**
 	* Stage offsets must leave at least one usable line in the stage.
 	*/
-	maxStageTotal: (grid) => Math.max(0, grid.linesPerStage - 1),
+	maxStageTotal: (flow) => Math.max(0, flow.linesPerStage - 1),
 	/**
 	* Page offsets must leave at least one usable line on the page, after stage offsets apply.
 	*/
-	maxPageTotal: (grid, stage) => Math.max(0, (grid.linesPerStage - LineOffset.total(stage)) * grid.stagesPerPage - 1)
+	maxPageTotal: (flow, stage) => Math.max(0, (flow.linesPerStage - LineOffset.total(stage)) * flow.stagesPerPage - 1)
+};
+//#endregion
+//#region src/composer/novel-flow-settings.ts
+const RANGES = {
+	lineLengthEm: {
+		min: 10,
+		max: 60
+	},
+	linesPerStage: {
+		min: 10,
+		max: 60
+	},
+	stagesPerPage: {
+		min: 1,
+		max: 3
+	}
+};
+const boundedCount = (bounds) => v.pipe(v.number(), v.finite(), v.integer(), v.minValue(bounds.min), v.maxValue(bounds.max));
+const NovelFlowSettings = {
+	schema: readonlyObject({
+		lineLengthEm: boundedCount(RANGES.lineLengthEm),
+		linesPerStage: boundedCount(RANGES.linesPerStage),
+		stagesPerPage: boundedCount(RANGES.stagesPerPage)
+	}),
+	ranges: RANGES,
+	defaults: {
+		lineLengthEm: 27,
+		linesPerStage: 23,
+		stagesPerPage: 2
+	}
 };
 //#endregion
 //#region src/composer/composition-settings.ts
-const ManuscriptCompositionSettingsSchema = v.pipe(readonlyObject({
-	grid: GridSettings.schema,
+const NovelCompositionSettingsSchema = v.pipe(readonlyObject({
+	flow: NovelFlowSettings.schema,
 	offsets: ManuscriptOffsets.schema,
 	appearance: ManuscriptAppearanceSettings.schema
-}), v.check(({ grid, offsets }) => LineOffset.total(offsets.stage) <= ManuscriptOffsets.maxStageTotal(grid) && LineOffset.total(offsets.page) <= ManuscriptOffsets.maxPageTotal(grid, offsets.stage), "page or stage offsets leave no usable manuscript lines"));
-const ManuscriptCompositionSettings = {
-	schema: ManuscriptCompositionSettingsSchema,
+}), v.check(({ flow, offsets }) => LineOffset.total(offsets.stage) <= ManuscriptOffsets.maxStageTotal(flow) && LineOffset.total(offsets.page) <= ManuscriptOffsets.maxPageTotal(flow, offsets.stage), "page or stage offsets leave no usable novel lines"));
+const NovelCompositionSettings = {
+	schema: NovelCompositionSettingsSchema,
 	defaults: {
-		grid: GridSettings.defaults,
+		flow: NovelFlowSettings.defaults,
 		offsets: ManuscriptOffsets.defaults,
 		appearance: ManuscriptAppearanceSettings.defaults
 	},
-	is: (value) => v.is(ManuscriptCompositionSettingsSchema, value)
+	is: (value) => v.is(NovelCompositionSettingsSchema, value)
 };
 const CompositionStatistics = { schema: readonlyObject({
 	chars: nonNegativeInteger(),
 	sourceLines: nonNegativeInteger(),
 	pages: nonNegativeInteger()
 }) };
-const GridCell = {
-	schema: readonlyObject({
-		value: v.nullable(v.string()),
-		range: v.nullable(ManuscriptRange.schema),
-		annotations: readonlyArray(ManuscriptAnnotation.schema)
-	}),
-	empty: () => ({
-		value: null,
-		range: null,
-		annotations: []
-	})
-};
-const GridLine = {
-	schema: readonlyObject({
-		range: v.nullable(ManuscriptRange.schema),
-		cells: readonlyArray(GridCell.schema)
-	}),
-	of: (cells) => ({
-		cells,
-		range: ManuscriptRange.merge(cells.map(({ range }) => range))
-	}),
-	/**
-	* Pads with empty cells so every line in a stage has the same length.
-	*/
-	padded: (cells, charsPerLine) => GridLine.of([...cells, ...Array.from({ length: Math.max(0, charsPerLine - cells.length) }, GridCell.empty)])
-};
-const GridStage = {
-	schema: readonlyObject({
-		range: v.nullable(ManuscriptRange.schema),
-		lines: readonlyArray(GridLine.schema)
-	}),
-	of: (lines) => ({
-		lines,
-		range: ManuscriptRange.merge(lines.map(({ range }) => range))
-	})
-};
-const GridPage = {
-	schema: readonlyObject({
-		range: v.nullable(ManuscriptRange.schema),
-		stages: readonlyArray(GridStage.schema)
-	}),
-	of: (stages) => ({
-		stages,
-		range: ManuscriptRange.merge(stages.map(({ range }) => range))
-	})
+//#endregion
+//#region src/composer/inline-measurer.ts
+function graphemeWidth(grapheme) {
+	let width = 1;
+	for (const character of grapheme) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint !== void 0) width = Math.max(width, eastAsianWidth(codePoint, { ambiguousAsWide: true }));
+	}
+	return width / 2;
+}
+/**
+* Deterministic Japanese-context measurement in logical em units.
+*/
+const logicalInlineMeasurer = (request) => {
+	const { text } = request;
+	const width = [...graphemeSegmenter.segment(text)].reduce((total, { segment }) => total + graphemeWidth(segment), 0);
+	if (request.role === "ruby") return width / 2;
+	return request.presentation === "upright" ? [...graphemeSegmenter.segment(text)].length : width;
 };
 //#endregion
 //#region src/composer/manuscript-geometry.ts
@@ -1107,8 +1169,8 @@ const ManuscriptGeometrySchema = readonlyObject({
 	cellSizeMm: nonNegativeLength(),
 	lineGapMm: nonNegativeLength(),
 	fontSizePt: FontSizePt.schema,
-	gridWidthMm: nonNegativeLength(),
-	gridHeightMm: nonNegativeLength(),
+	contentWidthMm: nonNegativeLength(),
+	contentHeightMm: nonNegativeLength(),
 	marginInlineMm: v.pipe(v.number(), v.finite()),
 	marginBlockMm: v.pipe(v.number(), v.finite()),
 	fitsPaper: v.boolean()
@@ -1116,59 +1178,255 @@ const ManuscriptGeometrySchema = readonlyObject({
 /**
 * Every stage stacked vertically, plus the gap between adjacent stages.
 */
-function gridHeightInCells(grid) {
-	return grid.stagesPerPage * grid.charsPerLine + STAGE_GAP_CELLS * (grid.stagesPerPage - 1);
+function contentHeightInEm(flow) {
+	return flow.stagesPerPage * flow.lineLengthEm + STAGE_GAP_CELLS * (flow.stagesPerPage - 1);
 }
 /**
 * Every vertical line side by side, plus the gap between adjacent lines.
 */
-function gridWidthInCells(grid) {
-	return grid.linesPerStage + LINE_GAP_CELLS * (grid.linesPerStage - 1);
+function contentWidthInEm(flow) {
+	return flow.linesPerStage + LINE_GAP_CELLS * (flow.linesPerStage - 1);
 }
 const ManuscriptGeometry = {
 	schema: ManuscriptGeometrySchema,
-	of: (grid, appearance) => {
+	of: (flow, appearance) => {
 		const paper = PaperSize.of(appearance.paperSize);
 		const cellSizeMm = ptToMm(appearance.fontSizePt);
-		const gridWidthMm = gridWidthInCells(grid) * cellSizeMm;
-		const gridHeightMm = gridHeightInCells(grid) * cellSizeMm;
-		const marginInlineMm = (paper.widthMm - gridWidthMm) / 2;
-		const marginBlockMm = (paper.heightMm - gridHeightMm) / 2;
+		const contentWidthMm = contentWidthInEm(flow) * cellSizeMm;
+		const contentHeightMm = contentHeightInEm(flow) * cellSizeMm;
+		const marginInlineMm = (paper.widthMm - contentWidthMm) / 2;
+		const marginBlockMm = (paper.heightMm - contentHeightMm) / 2;
 		return {
 			paperWidthMm: paper.widthMm,
 			paperHeightMm: paper.heightMm,
 			cellSizeMm,
 			lineGapMm: LINE_GAP_CELLS * cellSizeMm,
 			fontSizePt: appearance.fontSizePt,
-			gridWidthMm,
-			gridHeightMm,
+			contentWidthMm,
+			contentHeightMm,
 			marginInlineMm,
 			marginBlockMm,
 			fitsPaper: marginInlineMm >= 0 && marginBlockMm >= 0
 		};
 	},
 	/**
-	* The largest step-aligned point size whose grid still fits the paper, clamped to the range.
+	* The largest step-aligned point size whose text area still fits the paper.
 	*/
-	maxFontSizePt: (grid, paperSizeId) => {
+	maxFontSizePt: (flow, paperSizeId) => {
 		const paper = PaperSize.of(paperSizeId);
-		const maxCellSizeMm = Math.min(paper.widthMm / gridWidthInCells(grid), paper.heightMm / gridHeightInCells(grid));
+		const maxCellSizeMm = Math.min(paper.widthMm / contentWidthInEm(flow), paper.heightMm / contentHeightInEm(flow));
 		const steps = Math.floor(mmToPt(maxCellSizeMm) / FontSizePt.range.step + 1e-9);
 		const aligned = Math.round(steps * FontSizePt.range.step * 1e3) / 1e3;
 		return Math.min(FontSizePt.range.max, Math.max(FontSizePt.range.min, aligned));
 	}
 };
-const ManuscriptGridLayout = { schema: readonlyObject({
-	pages: readonlyArray(GridPage.schema),
+//#endregion
+//#region src/internal/japanese-brackets.ts
+/**
+* Brackets and quotes a Japanese paragraph may open with. Halfwidth forms are included because a
+* manuscript that uses them is still opening a paragraph, not writing prose.
+*/
+const OPENING_BRACKETS = "「『〖〈《（(“\"‘'［[〔｛{＜<";
+/**
+* The closing counterparts, in the same order.
+*/
+const CLOSING_BRACKETS = "」』〗〉》）)”\"’'］]〕｝}＞>";
+/**
+* Escapes the characters a regular expression character class would otherwise read as syntax, so a
+* set declared above can be dropped into a pattern.
+*/
+function characterClass(characters) {
+	return characters.replaceAll(/[\\\]^-]/gu, "\\$&");
+}
+//#endregion
+//#region src/internal/japanese-spaces.ts
+const LEADING_SPACES = /^[　 \t]+/u;
+/**
+* The run of spaces the text begins with, or an empty string. Halfwidth spaces and tabs count: a
+* rule has to see them to say they are the wrong space.
+*/
+function leadingSpaces(text) {
+	return LEADING_SPACES.exec(text)?.[0] ?? "";
+}
+//#endregion
+//#region src/internal/question-or-exclamation-spacing.ts
+/**
+* Runs, not single marks: `！？` is one mark and takes one gap, so the gap belongs after the run.
+*/
+const MARKS = /[？！]+/gu;
+function analyzeMatch(line, marks) {
+	const start = marks.index;
+	if (start === void 0) return void 0;
+	const marksRange = {
+		start,
+		end: start + marks[0].length
+	};
+	const next = line[marksRange.end];
+	if (next === void 0 || "」』〗〉》）)”\"’'］]〕｝}＞>".includes(next)) return void 0;
+	const spaces = leadingSpaces(line.slice(marksRange.end));
+	if (spaces === "") return {
+		kind: "missing",
+		marks: marksRange
+	};
+	const gap = {
+		start: marksRange.end,
+		end: marksRange.end + spaces.length
+	};
+	const following = line[gap.end];
+	if (following !== void 0 && "」』〗〉》）)”\"’'］]〕｝}＞>".includes(following)) return {
+		kind: "before-closing-bracket",
+		marks: marksRange,
+		gap
+	};
+	if (spaces !== "　") return {
+		kind: "invalid-space",
+		marks: marksRange,
+		gap
+	};
+	return {
+		kind: "valid",
+		marks: marksRange,
+		gap
+	};
+}
+/**
+* Classifies the spacing after each run of fullwidth question or exclamation marks in one display
+* line. Runs at the end of the line or immediately before a closing bracket need no gap and are
+* omitted from the result.
+*/
+function questionOrExclamationSpacings(line) {
+	return [...line.matchAll(MARKS)].map((marks) => analyzeMatch(line, marks)).filter((spacing) => spacing !== void 0);
+}
+//#endregion
+//#region src/composer/vertical-text-presentation.ts
+const common = { groupRange: ManuscriptRange.schema };
+const VerticalTextPresentation = { schema: v.variant("kind", [
+	readonlyObject({
+		kind: v.literal("mixed"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("upright"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("sideways"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("tate-chu-yoko"),
+		...common
+	})
+]) };
+//#endregion
+//#region src/composer/positioned-grapheme.ts
+const emLength = () => v.pipe(v.number(), v.finite(), v.minValue(0));
+const PositionedGrapheme = { schema: readonlyObject({
+	kind: v.literal("grapheme"),
+	value: v.string(),
+	range: ManuscriptRange.schema,
+	offsetEm: emLength(),
+	advanceEm: emLength(),
+	disposition: v.union([v.literal("placed"), v.literal("hanging")]),
+	presentation: VerticalTextPresentation.schema
+}) };
+const SuppressedGrapheme = { schema: readonlyObject({
+	kind: v.literal("suppressed"),
+	value: v.string(),
+	range: ManuscriptRange.schema,
+	reason: v.literal("question-or-exclamation-gap")
+}) };
+const NovelLine = {
+	schema: readonlyObject({
+		range: v.nullable(ManuscriptRange.schema),
+		advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0)),
+		graphemes: readonlyArray(PositionedGrapheme.schema),
+		suppressed: readonlyArray(SuppressedGrapheme.schema),
+		annotations: readonlyArray(ComposedAnnotationFragment.schema)
+	}),
+	empty: () => ({
+		range: null,
+		advanceEm: 0,
+		graphemes: [],
+		suppressed: [],
+		annotations: []
+	})
+};
+const NovelStage = {
+	schema: readonlyObject({
+		range: v.nullable(ManuscriptRange.schema),
+		lines: readonlyArray(NovelLine.schema)
+	}),
+	of: (lines) => ({
+		lines,
+		range: ManuscriptRange.merge(lines.map(({ range }) => range))
+	})
+};
+const NovelPage = {
+	schema: readonlyObject({
+		range: v.nullable(ManuscriptRange.schema),
+		stages: readonlyArray(NovelStage.schema)
+	}),
+	of: (stages) => ({
+		stages,
+		range: ManuscriptRange.merge(stages.map(({ range }) => range))
+	})
+};
+const NovelLayout = { schema: readonlyObject({
+	pages: readonlyArray(NovelPage.schema),
 	geometry: ManuscriptGeometry.schema,
 	stats: CompositionStatistics.schema
 }) };
 //#endregion
-//#region src/composer/grid-composer.ts
-const COMPOSER_ID = NamespacedId.of("kg/grid");
-/**
-* Splits display graphemes on line breaks. A trailing break does not create an empty last line.
-*/
+//#region src/composer/novel-composer.ts
+const COMPOSER_ID = NamespacedId.of("kg/novel");
+const LINE_START_PROHIBITED = /* @__PURE__ */ new Set(`、。，．・：；？！‼⁇⁈⁉ヽヾゝゞ々ーァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖ${CLOSING_BRACKETS}】〙〟｠»`);
+const LINE_END_PROHIBITED = /* @__PURE__ */ new Set(`${OPENING_BRACKETS}【〘〝｟«`);
+const HANGING_PUNCTUATION = /* @__PURE__ */ new Set("、。，．！？");
+const INSEPARABLE_PAIRS = /* @__PURE__ */ new Set([
+	"……",
+	"――",
+	"──",
+	"〳〵"
+]);
+const ASCII_ALPHANUMERIC = /^[A-Za-z0-9]$/u;
+const ASCII_TWO_DIGITS = /^[0-9]{2}$/u;
+const UPRIGHT_LATIN_ABBREVIATION = /^(?:[A-Z]+|[A-Z][a-z]{1,2})$/u;
+const FULLWIDTH_ALPHANUMERIC = /^[Ａ-Ｚａ-ｚ０-９]$/u;
+function presentation(kind, graphemes) {
+	const groupRange = ManuscriptRange.merge(graphemes.map(({ range }) => range));
+	return groupRange === null ? void 0 : {
+		kind,
+		groupRange
+	};
+}
+function presentedSourceLine(sourceLine) {
+	const presented = [];
+	let cursor = 0;
+	while (cursor < sourceLine.length) {
+		const first = sourceLine[cursor];
+		if (first === void 0) break;
+		if (!ASCII_ALPHANUMERIC.test(first.value)) {
+			const itemPresentation = presentation(FULLWIDTH_ALPHANUMERIC.test(first.value) ? "upright" : "mixed", [first]);
+			if (itemPresentation !== void 0) presented.push({
+				grapheme: first,
+				presentation: itemPresentation
+			});
+			cursor += 1;
+			continue;
+		}
+		const start = cursor;
+		while (ASCII_ALPHANUMERIC.test(sourceLine[cursor]?.value ?? "")) cursor += 1;
+		const run = sourceLine.slice(start, cursor);
+		const text = run.map(({ value }) => value).join("");
+		const runPresentation = presentation(ASCII_TWO_DIGITS.test(text) ? "tate-chu-yoko" : text.length === 1 || UPRIGHT_LATIN_ABBREVIATION.test(text) ? "upright" : "sideways", run);
+		if (runPresentation !== void 0) presented.push(...run.map((grapheme) => ({
+			grapheme,
+			presentation: runPresentation
+		})));
+	}
+	return presented;
+}
 function displayedLines(graphemes) {
 	const lines = [[]];
 	let endedWithLineBreak = false;
@@ -1178,35 +1436,326 @@ function displayedLines(graphemes) {
 			endedWithLineBreak = true;
 			continue;
 		}
-		lines.at(-1).push(grapheme);
+		lines.at(-1)?.push(grapheme);
 		endedWithLineBreak = false;
 	}
 	if (lines.length > 1 && endedWithLineBreak) lines.pop();
 	return lines;
 }
-function toCells(sourceLine, annotations) {
-	return sourceLine.map((grapheme) => ({
-		value: grapheme.value,
-		range: grapheme.range,
-		annotations: ManuscriptAnnotation.overlapping(annotations, grapheme.range)
+function validGapIndexes(sourceLine) {
+	const line = sourceLine.map(({ value }) => value).join("");
+	const gapStarts = new Set(questionOrExclamationSpacings(line).filter((spacing) => spacing.kind === "valid").map(({ gap }) => gap.start));
+	const indexes = /* @__PURE__ */ new Set();
+	let offset = 0;
+	for (const [index, grapheme] of sourceLine.entries()) {
+		if (gapStarts.has(offset)) indexes.add(index);
+		offset += grapheme.value.length;
+	}
+	return indexes;
+}
+function indicesInside(atoms, annotation) {
+	return atoms.flatMap(({ grapheme }, index) => ManuscriptRange.overlaps(grapheme.range, annotation.range) ? [index] : []);
+}
+function measure(measurer, text, role, settings, presentationKind) {
+	const context = {
+		text,
+		fontPreset: settings.appearance.fontPreset,
+		writingMode: "vertical-rl"
+	};
+	const value = role === "base" ? measurer({
+		...context,
+		role,
+		presentation: presentationKind ?? "mixed"
+	}) : measurer({
+		...context,
+		role
+	});
+	return Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function measureSourceLine(sourceLine, annotations, settings, measurer) {
+	const mutable = presentedSourceLine(sourceLine).map(({ grapheme, presentation }) => {
+		const advanceEm = measure(measurer, grapheme.value, "base", settings, presentation.kind);
+		return advanceEm === void 0 ? void 0 : {
+			grapheme,
+			advanceEm,
+			presentation
+		};
+	});
+	if (mutable.some((atom) => atom === void 0)) return void 0;
+	const atoms = mutable.flatMap((atom) => atom === void 0 ? [] : [atom]);
+	for (const annotation of annotations) {
+		if (annotation.kind !== "ruby") continue;
+		const indexes = indicesInside(atoms, annotation);
+		if (indexes.length === 0) continue;
+		if ((annotation.reading.kind === "group" ? [annotation.reading.text] : annotation.reading.segments).some((text) => [...graphemeSegmenter.segment(text)].some(({ segment }) => measure(measurer, segment, "ruby", settings) === void 0))) return void 0;
+		if (annotation.reading.kind === "group") {
+			const readingAdvance = measure(measurer, annotation.reading.text, "ruby", settings);
+			if (readingAdvance === void 0) return void 0;
+			const baseAdvance = indexes.reduce((total, index) => total + (atoms[index]?.advanceEm ?? 0), 0);
+			const extra = Math.max(0, readingAdvance - baseAdvance) / indexes.length;
+			for (const index of indexes) {
+				const atom = atoms[index];
+				if (atom !== void 0) atom.advanceEm += extra;
+			}
+			continue;
+		}
+		for (const [segmentIndex, index] of indexes.entries()) {
+			const segment = annotation.reading.segments[segmentIndex];
+			const atom = atoms[index];
+			if (segment === void 0 || atom === void 0) continue;
+			const readingAdvance = measure(measurer, segment, "ruby", settings);
+			if (readingAdvance === void 0) return void 0;
+			atom.advanceEm = Math.max(atom.advanceEm, readingAdvance);
+		}
+	}
+	return {
+		atoms,
+		suppressedIndexes: validGapIndexes(sourceLine)
+	};
+}
+function breakInsideFittableGroupRuby(atoms, annotations, boundary, lineLengthEm) {
+	const right = atoms[boundary];
+	if (right === void 0) return false;
+	const graphemeIndex = right.grapheme.range.graphemes.start;
+	return annotations.some((annotation) => {
+		if (annotation.kind !== "ruby" || annotation.reading.kind !== "group") return false;
+		if (graphemeIndex <= annotation.range.graphemes.start || graphemeIndex >= annotation.range.graphemes.end) return false;
+		return indicesInside(atoms, annotation).reduce((total, index) => total + (atoms[index]?.advanceEm ?? 0), 0) <= lineLengthEm;
+	});
+}
+function samePresentationGroup(left, right) {
+	return left.presentation.groupRange.graphemes.start === right.presentation.groupRange.graphemes.start && left.presentation.groupRange.graphemes.end === right.presentation.groupRange.graphemes.end;
+}
+function legalBoundary(atoms, annotations, boundary, lineLengthEm) {
+	const left = atoms[boundary - 1];
+	const right = atoms[boundary];
+	if (left === void 0 || right === void 0) return true;
+	return !samePresentationGroup(left, right) && !LINE_END_PROHIBITED.has(left.grapheme.value) && !LINE_START_PROHIBITED.has(right.grapheme.value) && !INSEPARABLE_PAIRS.has(left.grapheme.value + right.grapheme.value) && !breakInsideFittableGroupRuby(atoms, annotations, boundary, lineLengthEm);
+}
+function continuationFor(annotation, range) {
+	const starts = range.graphemes.start === annotation.range.graphemes.start;
+	const ends = range.graphemes.end === annotation.range.graphemes.end;
+	if (starts && ends) return "whole";
+	if (starts) return "start";
+	if (ends) return "end";
+	return "middle";
+}
+function groupReadingsForFragments(annotation, fragmentRanges, baseAdvances) {
+	const baseLength = annotation.range.graphemes.end - annotation.range.graphemes.start;
+	if (annotation.reading.kind !== "group") return [];
+	const reading = [...graphemeSegmenter.segment(annotation.reading.text)].map(({ segment }) => segment);
+	const advances = Array.from({ length: baseLength }, (_, index) => baseAdvances.get(annotation.range.graphemes.start + index));
+	const measured = advances.every((advance) => advance !== void 0);
+	const advanceFor = (fragment) => {
+		const fragmentStart = fragment.graphemes.start - annotation.range.graphemes.start;
+		const fragmentLength = fragment.graphemes.end - fragment.graphemes.start;
+		return measured ? advances.slice(fragmentStart, fragmentStart + fragmentLength).reduce((total, advance) => total + advance, 0) : fragmentLength;
+	};
+	const weights = fragmentRanges.map(advanceFor);
+	const effectiveWeights = weights.reduce((total, weight) => total + weight, 0) > 0 ? weights : fragmentRanges.map(({ graphemes }) => graphemes.end - graphemes.start);
+	const totalWeight = effectiveWeights.reduce((total, weight) => total + weight, 0);
+	const reserveEveryFragment = reading.length >= fragmentRanges.length;
+	const fragments = [];
+	let readingStart = 0;
+	let accumulatedWeight = 0;
+	for (const [index, weight] of effectiveWeights.entries()) {
+		accumulatedWeight += weight;
+		const remainingFragments = effectiveWeights.length - index - 1;
+		const proportionalEnd = index === effectiveWeights.length - 1 ? reading.length : Math.round(accumulatedWeight * reading.length / totalWeight);
+		const minimumEnd = reserveEveryFragment ? readingStart + 1 : readingStart;
+		const maximumEnd = reserveEveryFragment ? reading.length - remainingFragments : reading.length;
+		const readingEnd = Math.min(maximumEnd, Math.max(minimumEnd, proportionalEnd));
+		fragments.push(reading.slice(readingStart, readingEnd).join(""));
+		readingStart = readingEnd;
+	}
+	return fragments;
+}
+function readingForFragment(annotation, range, fragmentPlan) {
+	const start = range.graphemes.start - annotation.range.graphemes.start;
+	const length = range.graphemes.end - range.graphemes.start;
+	if (annotation.reading.kind !== "group") return {
+		kind: annotation.reading.kind,
+		text: annotation.reading.segments.slice(start, start + length).join("")
+	};
+	const fragmentIndex = fragmentPlan.ranges.findIndex(({ graphemes }) => graphemes.start === range.graphemes.start && graphemes.end === range.graphemes.end);
+	return {
+		kind: "group",
+		text: fragmentPlan.groupReadings[fragmentIndex] ?? ""
+	};
+}
+function positionReading(text, baseOffsetEm, baseAdvanceEm, settings, measurer) {
+	const measured = [...graphemeSegmenter.segment(text)].map(({ segment }) => ({
+		value: segment,
+		advanceEm: measure(measurer, segment, "ruby", settings) ?? 0
 	}));
+	const total = measured.reduce((sum, grapheme) => sum + grapheme.advanceEm, 0);
+	const edgeGap = measured.length > 0 && total < baseAdvanceEm ? (baseAdvanceEm - total) / (2 * measured.length) : 0;
+	let offsetEm = baseOffsetEm + (total > baseAdvanceEm ? (baseAdvanceEm - total) / 2 : edgeGap);
+	return measured.map((grapheme, index) => {
+		const positioned = {
+			value: grapheme.value,
+			advanceEm: grapheme.advanceEm,
+			offsetEm
+		};
+		offsetEm += grapheme.advanceEm;
+		if (index < measured.length - 1) offsetEm += edgeGap * 2;
+		return positioned;
+	});
 }
-/**
-* Wraps one source line across as many grid lines as its length requires.
-*/
-function wrapLine(cells, charsPerLine) {
-	if (cells.length === 0) return [GridLine.padded([], charsPerLine)];
-	return Array.from({ length: Math.ceil(cells.length / charsPerLine) }, (_unused, index) => GridLine.padded(cells.slice(index * charsPerLine, (index + 1) * charsPerLine), charsPerLine));
+function annotationFragmentRange(graphemes, suppressed, annotation) {
+	return ManuscriptRange.merge([...graphemes.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range), ...suppressed.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range)]);
+}
+function annotationFragments(graphemes, suppressed, annotations, settings, measurer, fragmentPlansByAnnotation) {
+	const fragments = [];
+	for (const annotation of annotations) {
+		const covered = graphemes.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range));
+		const fragmentRange = annotationFragmentRange(graphemes, suppressed, annotation);
+		const first = covered[0];
+		const last = covered.at(-1);
+		if (fragmentRange === null || first === void 0 || last === void 0) continue;
+		const common = {
+			annotationRange: annotation.range,
+			fragmentRange,
+			continuation: continuationFor(annotation, fragmentRange)
+		};
+		switch (annotation.kind) {
+			case "bold":
+			case "italic":
+				fragments.push({
+					kind: annotation.kind,
+					...common
+				});
+				break;
+			case "emphasis":
+				fragments.push({
+					kind: "emphasis",
+					mark: annotation.mark,
+					...common
+				});
+				break;
+			case "ruby": {
+				const fragmentPlan = fragmentPlansByAnnotation.get(annotation);
+				if (fragmentPlan === void 0) break;
+				const baseOffsetEm = first.offsetEm;
+				const baseAdvanceEm = last.offsetEm + last.advanceEm - baseOffsetEm;
+				const reading = readingForFragment(annotation, fragmentRange, fragmentPlan);
+				fragments.push({
+					kind: "ruby",
+					rubyKind: reading.kind,
+					reading: reading.text,
+					baseOffsetEm,
+					baseAdvanceEm,
+					readingGraphemes: positionReading(reading.text, baseOffsetEm, baseAdvanceEm, settings, measurer),
+					...common
+				});
+				break;
+			}
+		}
+	}
+	return fragments;
+}
+function positionedLine(atoms, dispositions, suppressed) {
+	let offsetEm = 0;
+	const graphemes = atoms.map(({ grapheme, advanceEm, presentation }, index) => {
+		const positioned = {
+			kind: "grapheme",
+			value: grapheme.value,
+			range: grapheme.range,
+			offsetEm,
+			advanceEm,
+			disposition: dispositions.has(index) ? "hanging" : "placed",
+			presentation
+		};
+		offsetEm += advanceEm;
+		return positioned;
+	});
+	return {
+		range: ManuscriptRange.merge([...graphemes.map(({ range }) => range), ...suppressed.map(({ range }) => range)]),
+		advanceEm: offsetEm,
+		graphemes,
+		suppressed,
+		annotations: []
+	};
+}
+function wrapSourceLine(sourceLine, annotations, settings, measurer, baseAdvances) {
+	if (sourceLine.atoms.length === 0) return [NovelLine.empty()];
+	const lines = [];
+	let cursor = 0;
+	while (cursor < sourceLine.atoms.length) {
+		const suppressed = [];
+		if (lines.length > 0 && sourceLine.suppressedIndexes.has(cursor)) {
+			const atom = sourceLine.atoms[cursor];
+			if (atom !== void 0) suppressed.push({
+				kind: "suppressed",
+				value: atom.grapheme.value,
+				range: atom.grapheme.range,
+				reason: "question-or-exclamation-gap"
+			});
+			cursor += 1;
+		}
+		if (cursor >= sourceLine.atoms.length) {
+			const previous = lines.at(-1);
+			if (previous !== void 0 && suppressed.length > 0) lines[lines.length - 1] = {
+				...previous,
+				range: ManuscriptRange.merge([...previous.range === null ? [] : [previous.range], ...suppressed.map(({ range }) => range)]),
+				suppressed: [...previous.suppressed, ...suppressed]
+			};
+			break;
+		}
+		const start = cursor;
+		let advance = 0;
+		while (cursor < sourceLine.atoms.length) {
+			const atom = sourceLine.atoms[cursor];
+			if (atom === void 0) break;
+			const previous = sourceLine.atoms[cursor - 1];
+			const beginsPresentationGroup = previous === void 0 || !samePresentationGroup(previous, atom);
+			if (cursor > start && beginsPresentationGroup) {
+				let groupAdvance = 0;
+				for (let index = cursor; index < sourceLine.atoms.length; index += 1) {
+					const member = sourceLine.atoms[index];
+					if (member === void 0 || !samePresentationGroup(atom, member)) break;
+					groupAdvance += member.advanceEm;
+				}
+				if (advance + groupAdvance > settings.flow.lineLengthEm) break;
+			}
+			if (cursor > start && advance + atom.advanceEm > settings.flow.lineLengthEm && (previous === void 0 || !samePresentationGroup(previous, atom))) break;
+			advance += atom.advanceEm;
+			cursor += 1;
+		}
+		let end = Math.max(start + 1, cursor);
+		const hanging = /* @__PURE__ */ new Set();
+		const next = sourceLine.atoms[end];
+		if (next !== void 0 && HANGING_PUNCTUATION.has(next.grapheme.value)) {
+			hanging.add(end - start);
+			end += 1;
+		} else while (end > start + 1 && !legalBoundary(sourceLine.atoms, annotations, end, settings.flow.lineLengthEm)) end -= 1;
+		const atoms = sourceLine.atoms.slice(start, end);
+		lines.push(positionedLine(atoms, hanging, suppressed));
+		cursor = end;
+	}
+	const fragmentPlansByAnnotation = new Map(annotations.map((annotation) => {
+		const ranges = lines.flatMap((line) => {
+			const range = annotationFragmentRange(line.graphemes, line.suppressed, annotation);
+			return range === null ? [] : [range];
+		});
+		return [annotation, {
+			ranges,
+			groupReadings: annotation.kind === "ruby" ? groupReadingsForFragments(annotation, ranges, baseAdvances) : []
+		}];
+	}));
+	return lines.map((line) => ({
+		range: line.range,
+		advanceEm: line.advanceEm,
+		graphemes: line.graphemes,
+		suppressed: line.suppressed,
+		annotations: annotationFragments(line.graphemes, line.suppressed, annotations, settings, measurer, fragmentPlansByAnnotation)
+	}));
 }
-function blankLines(count, charsPerLine) {
-	return Array.from({ length: count }, () => GridLine.padded([], charsPerLine));
+function blankLines(count) {
+	return Array.from({ length: count }, NovelLine.empty);
 }
-/**
-* Walks every line position on every page in reading order, handing out content lines only where
-* the stage and page offsets leave room. Always emits at least one page.
-*/
 function buildPages(contentLines, settings) {
-	const { charsPerLine, linesPerStage, stagesPerPage } = settings.grid;
+	const { linesPerStage, stagesPerPage } = settings.flow;
 	const { stage: stageOffset, page: pageOffset } = settings.offsets;
 	const usablePerStage = linesPerStage - LineOffset.total(stageOffset);
 	const usablePerPage = usablePerStage * stagesPerPage;
@@ -1222,48 +1771,51 @@ function buildPages(contentLines, settings) {
 				const withinPage = usableIndex >= pageOffset.leading && usableIndex < usablePerPage - pageOffset.trailing;
 				const next = contentLines[contentIndex];
 				if (!withinStage || !withinPage || next === void 0) {
-					lines.push(GridLine.padded([], charsPerLine));
+					lines.push(NovelLine.empty());
 					continue;
 				}
 				lines.push(next);
 				contentIndex += 1;
 			}
-			stages.push(GridStage.of(lines));
+			stages.push(NovelStage.of(lines));
 		}
-		pages.push(GridPage.of(stages));
+		pages.push(NovelPage.of(stages));
 	}
 	return pages;
 }
-function composeGrid(manuscript, settings) {
-	const { charsPerLine } = settings.grid;
-	const sourceLines = displayedLines(manuscript.graphemes);
-	const cellLines = sourceLines.map((line) => toCells(line, manuscript.annotations));
-	const manuscriptLines = cellLines.flatMap((cells) => wrapLine(cells, charsPerLine));
-	const pages = buildPages([
-		...blankLines(settings.offsets.document.leading, charsPerLine),
-		...manuscriptLines,
-		...blankLines(settings.offsets.document.trailing, charsPerLine)
-	], settings);
-	return ManuscriptResult.succeed({
-		pages,
-		geometry: ManuscriptGeometry.of(settings.grid, settings.appearance),
-		stats: {
-			chars: cellLines.reduce((total, cells) => total + cells.length, 0),
-			sourceLines: sourceLines.length,
-			pages: pages.length
-		}
-	});
+function createCompose(measurer) {
+	return (manuscript, settings) => {
+		const sourceLines = displayedLines(manuscript.graphemes);
+		const measured = sourceLines.map((line) => measureSourceLine(line, manuscript.annotations, settings, measurer));
+		if (measured.some((line) => line === void 0)) return ManuscriptResult.fail({ reason: "inline measurer returned a negative or non-finite value" });
+		const baseAdvances = /* @__PURE__ */ new Map();
+		for (const line of measured) for (const atom of line?.atoms ?? []) baseAdvances.set(atom.grapheme.range.graphemes.start, atom.advanceEm);
+		const manuscriptLines = measured.flatMap((line) => line === void 0 ? [] : wrapSourceLine(line, manuscript.annotations, settings, measurer, baseAdvances));
+		const pages = buildPages([
+			...blankLines(settings.offsets.document.leading),
+			...manuscriptLines,
+			...blankLines(settings.offsets.document.trailing)
+		], settings);
+		return ManuscriptResult.succeed({
+			pages,
+			geometry: ManuscriptGeometry.of(settings.flow, settings.appearance),
+			stats: {
+				chars: sourceLines.reduce((total, line) => total + line.length, 0),
+				sourceLines: sourceLines.length,
+				pages: pages.length
+			}
+		});
+	};
 }
-/**
-* Places text on Japanese manuscript paper: vertical lines grouped into stages, stages into pages.
-* Settings arrive already validated by {@link composeManuscript}, so this never rejects.
-*/
-const manuscriptGridComposer = {
-	id: COMPOSER_ID,
-	settingsSchema: ManuscriptCompositionSettings.schema,
-	layoutSchema: ManuscriptGridLayout.schema,
-	compose: composeGrid
-};
+function createNovelComposer(options) {
+	return {
+		id: COMPOSER_ID,
+		settingsSchema: NovelCompositionSettings.schema,
+		layoutSchema: NovelLayout.schema,
+		compose: createCompose(options.measurer)
+	};
+}
+const novelComposer = createNovelComposer({ measurer: logicalInlineMeasurer });
 //#endregion
 //#region src/proofreading/invalid-rule-options.ts
 const InvalidRuleOptions = { describe: (error) => `ルール ${error.ruleId} のオプション "${error.option}" が不正です: ${error.issues.map(({ message }) => message).join(", ")}` };
@@ -1544,7 +2096,7 @@ function defineMatchRule(options) {
 }
 //#endregion
 //#region src/proofreading/rules/consistent-kanji-opening.ts
-const RULE_ID$6 = "kg/consistent-kanji-opening";
+const RULE_ID$5 = "kg/consistent-kanji-opening";
 const MESSAGE = "「{{ closed }}」と「{{ opened }}」が混在しています。文脈上の使い分けか表記ゆれかを確認してください";
 const KanjiOpeningPairSchema = v.pipe(readonlyObject({
 	closed: v.pipe(v.string(), v.nonEmpty()),
@@ -1598,7 +2150,7 @@ const DEFAULT_PAIRS = [
 * two spellings are a deliberate distinction is the author's call, so the finding is a warning.
 */
 function build$3(pairs) {
-	return defineParsedRule(RULE_ID$6, MESSAGE, (manuscript, report) => {
+	return defineParsedRule(RULE_ID$5, MESSAGE, (manuscript, report) => {
 		for (const { closed, opened } of pairs) {
 			if (!manuscript.displayText.includes(opened)) continue;
 			const index = manuscript.displayText.indexOf(closed);
@@ -1619,7 +2171,7 @@ function createConsistentKanjiOpeningRule(options = {}) {
 	const pairs = v.safeParse(PairsSchema, options.pairs);
 	if (!pairs.success) return ManuscriptResult.fail({
 		kind: "InvalidRuleOptions",
-		ruleId: RULE_ID$6,
+		ruleId: RULE_ID$5,
 		option: "pairs",
 		issues: ValidationIssue.from(pairs.issues)
 	});
@@ -1664,7 +2216,7 @@ const consistentNumeralWidthRule = () => defineMixedWidthRule({
 });
 //#endregion
 //#region src/proofreading/rules/dash.ts
-const RULE_ID$5 = "kg/dash";
+const RULE_ID$4 = "kg/dash";
 const DEFAULT_PREFERRED = "―";
 const DashCharacterSchema = v.picklist([
 	"―",
@@ -1686,7 +2238,7 @@ function build$2(preferred) {
 	return {
 		kind: "parsed",
 		meta: {
-			id: RULE_ID$5,
+			id: RULE_ID$4,
 			messages
 		},
 		check: (manuscript, context) => {
@@ -1715,7 +2267,7 @@ function createDashRule(options = {}) {
 	const preferred = v.safeParse(DashCharacterSchema, options.preferred);
 	if (!preferred.success) return ManuscriptResult.fail({
 		kind: "InvalidRuleOptions",
-		ruleId: RULE_ID$5,
+		ruleId: RULE_ID$4,
 		option: "preferred",
 		issues: ValidationIssue.from(preferred.issues)
 	});
@@ -1742,8 +2294,8 @@ const evenEllipsisRule = () => defineMatchRule({
 });
 //#endregion
 //#region src/proofreading/rules/fullwidth-japanese-punctuation.ts
-const RULE_ID$4 = "kg/fullwidth-japanese-punctuation";
-const MESSAGES$3 = {
+const RULE_ID$3 = "kg/fullwidth-japanese-punctuation";
+const MESSAGES$2 = {
 	"halfwidth-japanese-punctuation": "半角の「{{ character }}」があります。日本語の句読点・括弧・感嘆符・疑問符は全角にしてください",
 	"halfwidth-near-japanese": "日本語の前後に半角の「{{ character }}」があります。全角にすべきか確認してください"
 };
@@ -1788,8 +2340,8 @@ function isEllipsisSubstitute(text, index) {
 const fullwidthJapanesePunctuationRule = () => ({
 	kind: "parsed",
 	meta: {
-		id: RULE_ID$4,
-		messages: MESSAGES$3
+		id: RULE_ID$3,
+		messages: MESSAGES$2
 	},
 	check: (manuscript, context) => {
 		for (const line of splitDisplayLines(manuscript.displayText)) for (const { pattern, messageId, severity, requiresJapanese } of CHECKS) for (const match of line.text.matchAll(pattern)) {
@@ -1807,12 +2359,12 @@ const fullwidthJapanesePunctuationRule = () => ({
 });
 //#endregion
 //#region src/proofreading/rules/max-arabic-numeral-digits.ts
-const RULE_ID$3 = "kg/max-arabic-numeral-digits";
+const RULE_ID$2 = "kg/max-arabic-numeral-digits";
 const DEFAULT_MAX_DIGITS = 2;
 const MaxDigitsSchema = v.pipe(v.number(), v.finite(), v.integer(), v.minValue(1));
 function build$1(maxDigits) {
 	return defineMatchRule({
-		id: RULE_ID$3,
+		id: RULE_ID$2,
 		pattern: /([0-9０-９]+)(?:[.．]([0-9０-９]+))?/gu,
 		accept: (match) => (match[1]?.length ?? 0) > maxDigits || (match[2]?.length ?? 0) > maxDigits,
 		message: `${maxDigits}桁を超えるアラビア数字が使われています`
@@ -1824,7 +2376,7 @@ function createMaxArabicNumeralDigitsRule(options = {}) {
 	const maxDigits = v.safeParse(MaxDigitsSchema, options.maxDigits);
 	if (!maxDigits.success) return ManuscriptResult.fail({
 		kind: "InvalidRuleOptions",
-		ruleId: RULE_ID$3,
+		ruleId: RULE_ID$2,
 		option: "maxDigits",
 		issues: ValidationIssue.from(maxDigits.issues)
 	});
@@ -1852,24 +2404,6 @@ const noConsecutivePunctuationRule = () => defineMatchRule({
 	message: "句読点が連続しています"
 });
 //#endregion
-//#region src/proofreading/rules/internal/brackets.ts
-/**
-* Brackets and quotes a Japanese paragraph may open with. Halfwidth forms are included because a
-* manuscript that uses them is still opening a paragraph, not writing prose.
-*/
-const OPENING_BRACKETS = "「『〖〈《（(“\"‘'［[〔｛{＜<";
-/**
-* The closing counterparts, in the same order.
-*/
-const CLOSING_BRACKETS = "」』〗〉》）)”\"’'］]〕｝}＞>";
-/**
-* Escapes the characters a regular expression character class would otherwise read as syntax, so a
-* set declared above can be dropped into a pattern.
-*/
-function characterClass(characters) {
-	return characters.replaceAll(/[\\\]^-]/gu, "\\$&");
-}
-//#endregion
 //#region src/proofreading/rules/internal/decoration-line.ts
 const DECORATION_LINE = /^[＊*◆◇■□●○▽▼△▲☆★・…―─━ー\-=＝~～\s]+$/u;
 /**
@@ -1880,19 +2414,9 @@ function isDecorationLine(text) {
 	return DECORATION_LINE.test(text);
 }
 //#endregion
-//#region src/proofreading/rules/internal/spaces.ts
-const LEADING_SPACES = /^[　 \t]+/u;
-/**
-* The run of spaces the text begins with, or an empty string. Halfwidth spaces and tabs count: a
-* rule has to see them to say they are the wrong space.
-*/
-function leadingSpaces(text) {
-	return LEADING_SPACES.exec(text)?.[0] ?? "";
-}
-//#endregion
 //#region src/proofreading/rules/paragraph-opening.ts
-const RULE_ID$2 = "kg/paragraph-opening";
-const MESSAGES$2 = {
+const RULE_ID$1 = "kg/paragraph-opening";
+const MESSAGES$1 = {
 	"leading-character": "段落の先頭には全角スペースまたは開き括弧が必要です",
 	"indent-width": "段落冒頭の字下げは全角スペース1字にしてください",
 	"unexpected-indent": "括弧から始まる段落を字下げすることはできません"
@@ -1907,8 +2431,8 @@ function build(openingBrackets) {
 	return {
 		kind: "parsed",
 		meta: {
-			id: RULE_ID$2,
-			messages: MESSAGES$2
+			id: RULE_ID$1,
+			messages: MESSAGES$1
 		},
 		check: (manuscript, context) => {
 			const report = (start, end, messageId) => {
@@ -1938,7 +2462,7 @@ function createParagraphOpeningRule(options = {}) {
 	const brackets = v.safeParse(OpeningBracketsSchema, options.openingBrackets);
 	if (!brackets.success) return ManuscriptResult.fail({
 		kind: "InvalidRuleOptions",
-		ruleId: RULE_ID$2,
+		ruleId: RULE_ID$1,
 		option: "openingBrackets",
 		issues: ValidationIssue.from(brackets.issues)
 	});
@@ -1954,25 +2478,21 @@ const punctuationBeforeClosingQuoteRule = () => defineMatchRule({
 });
 //#endregion
 //#region src/proofreading/rules/space-after-question-or-exclamation.ts
-const RULE_ID$1 = "kg/space-after-question-or-exclamation";
-const MESSAGES$1 = {
+const RULE_ID = "kg/space-after-question-or-exclamation";
+const MESSAGES = {
 	default: "感嘆符または疑問符の直後には全角スペースか閉じ括弧が必要です",
 	"space-width": "感嘆符または疑問符の直後の空白は全角スペース1字にしてください",
 	"before-closing-bracket": "閉じ括弧の直前に空白を置くことはできません"
 };
 /**
-* Runs, not single marks: `！？` is one mark and takes one gap, so the gap belongs after the run.
-*/
-const MARKS = /[？！]+/gu;
-/**
 * Checks the gap that follows every run of ！ or ？. A run at the end of a line or right before a
 * closing bracket needs no gap; anywhere else it takes exactly one ideographic space.
 */
 const spaceAfterQuestionOrExclamationRule = () => ({
 	kind: "parsed",
 	meta: {
-		id: RULE_ID$1,
-		messages: MESSAGES$1
+		id: RULE_ID,
+		messages: MESSAGES
 	},
 	check: (manuscript, context) => {
 		const report = (start, end, messageId) => {
@@ -1981,93 +2501,39 @@ const spaceAfterQuestionOrExclamationRule = () => ({
 				messageId
 			});
 		};
-		for (const line of splitDisplayLines(manuscript.displayText)) for (const marks of line.text.matchAll(MARKS)) {
-			const marksEnd = marks.index + marks[0].length;
-			const next = line.text[marksEnd];
-			if (next === void 0 || "」』〗〉》）)”\"’'］]〕｝}＞>".includes(next)) continue;
-			const spaces = leadingSpaces(line.text.slice(marksEnd));
-			if (spaces === "") {
-				report(line.start + marks.index, line.start + marksEnd, "default");
-				continue;
-			}
-			const following = line.text[marksEnd + spaces.length];
-			const spacesStart = line.start + marksEnd;
-			const spacesEnd = spacesStart + spaces.length;
-			if (following !== void 0 && "」』〗〉》）)”\"’'］]〕｝}＞>".includes(following)) report(spacesStart, spacesEnd, "before-closing-bracket");
-			else if (spaces !== "　") report(spacesStart, spacesEnd, "space-width");
+		for (const line of splitDisplayLines(manuscript.displayText)) for (const spacing of questionOrExclamationSpacings(line.text)) switch (spacing.kind) {
+			case "valid": break;
+			case "missing":
+				report(line.start + spacing.marks.start, line.start + spacing.marks.end, "default");
+				break;
+			case "invalid-space":
+				report(line.start + spacing.gap.start, line.start + spacing.gap.end, "space-width");
+				break;
+			case "before-closing-bracket":
+				report(line.start + spacing.gap.start, line.start + spacing.gap.end, "before-closing-bracket");
+				break;
+			default: assertNever(spacing);
 		}
 	}
 });
 //#endregion
 //#region src/proofreading/rules/variant-character.ts
-const RULE_ID = "kg/variant-character";
-const MESSAGES = {
-	default: "異体字または字形選択子が使われています",
-	"with-suggestion": "異体字または字形選択子が使われています。「{{ suggestion }}」ではありませんか？"
-};
 /**
-* Mongolian free variation selectors, variation selectors (incl. emoji presentation), IVSes: all
-* combine with a preceding base character rather than standing on their own.
+* Mongolian free variation selectors, variation selectors, CJK compatibility ideographs, IVSes.
 */
-function isSelector(codePoint) {
-	return codePoint >= 6155 && codePoint <= 6157 || codePoint === 6159 || codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999;
-}
-/**
-* CJK compatibility ideographs stand alone; each has a canonical unified form reachable via NFKC.
-*/
-function isCompatibilityIdeograph(codePoint) {
-	return codePoint >= 63744 && codePoint <= 64255 || codePoint >= 194560 && codePoint <= 195103;
-}
 function isVariantCharacter(character) {
 	const codePoint = character.codePointAt(0);
 	if (codePoint === void 0) return false;
-	return isSelector(codePoint) || isCompatibilityIdeograph(codePoint);
-}
-/**
-* The plain form a reader would expect: the selector stripped away, or the compatibility
-* ideograph's canonical unified form. Undefined when that plain form is identical to the original,
-* since NFKC does not touch selectors and a suggestion equal to the input helps no one.
-*/
-function suggestPlainForm(segment) {
-	const withoutSelectors = Array.from(segment).filter((character) => {
-		const codePoint = character.codePointAt(0);
-		return codePoint !== void 0 && !isSelector(codePoint);
-	}).join("");
-	if (withoutSelectors === "") return void 0;
-	const normalized = Array.from(withoutSelectors).map((character) => {
-		const codePoint = character.codePointAt(0);
-		return codePoint !== void 0 && isCompatibilityIdeograph(codePoint) ? character.normalize("NFKC") : character;
-	}).join("");
-	return normalized === segment ? void 0 : normalized;
+	return codePoint >= 6155 && codePoint <= 6157 || codePoint === 6159 || codePoint >= 65024 && codePoint <= 65039 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 194560 && codePoint <= 195103 || codePoint >= 917760 && codePoint <= 917999;
 }
 /**
 * Scans the source rather than the display text: notation removal must not hide a variant.
 */
-const variantCharacterRule = () => ({
-	kind: "parsed",
-	meta: {
-		id: RULE_ID,
-		messages: MESSAGES
-	},
-	check: (manuscript, context) => {
-		for (const { index, segment } of graphemeSegmenter.segment(manuscript.source)) {
-			if (!Array.from(segment).some(isVariantCharacter)) continue;
-			const range = sourceRange(manuscript, {
-				start: index,
-				end: index + segment.length
-			});
-			const suggestion = suggestPlainForm(segment);
-			if (suggestion === void 0) context.report({
-				range,
-				messageId: "default"
-			});
-			else context.report({
-				range,
-				messageId: "with-suggestion",
-				data: { suggestion }
-			});
-		}
-	}
+const variantCharacterRule = () => defineParsedRule("kg/variant-character", "異体字または字形選択子が使われています", (manuscript, report) => {
+	for (const { index, segment } of graphemeSegmenter.segment(manuscript.source)) if (Array.from(segment).some(isVariantCharacter)) report(sourceRange(manuscript, {
+		start: index,
+		end: index + segment.length
+	}));
 });
 //#endregion
 //#region src/proofreading/rules/default-rules.ts
@@ -2095,4 +2561,4 @@ function createDefaultProofreadingRules() {
 	];
 }
 //#endregion
-export { BoldAnnotation, ComposeError, CompositionStatistics, DiagnosticOrigin, DiagnosticSeverity, DisplayRange, EmphasisAnnotation, FontPreset, FontPresetId, FontSizePt, GraphemeRange, GridCell, GridLine, GridPage, GridSettings, GridStage, InvalidRuleOptions, ItalicAnnotation, LineOffset, ManuscriptAnnotation, ManuscriptAppearanceSettings, ManuscriptCompositionSettings, ManuscriptDiagnostic, ManuscriptGeometry, ManuscriptGridLayout, ManuscriptOffsets, ManuscriptRange, ManuscriptResult, NamespacedId, PaperSize, PaperSizeId, ParseError, ParsedGrapheme, ParsedManuscript, ProofreadError, ProofreadingReport, ProofreadingRuleMeta, Rejection, RubyAnnotation, SourcePosition, SourceRange, TextRange, ValidationIssue, assertNever, composeManuscript, consistentKanjiOpeningRule, consistentLatinWidthRule, consistentNumeralWidthRule, createConsistentKanjiOpeningRule, createDashRule, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createParagraphOpeningRule, dashRule, ellipsisCharacterRule, evenEllipsisRule, fullwidthJapanesePunctuationRule, kakuyomuParser, manuscriptGridComposer, maxArabicNumeralDigitsRule, minusBeforeNumberRule, mmToPt, noConsecutiveInterpunctRule, noConsecutivePunctuationRule, paragraphOpeningRule, parseManuscript, pixivParser, plainTextParser, proofreadManuscript, ptToMm, punctuationBeforeClosingQuoteRule, spaceAfterQuestionOrExclamationRule, variantCharacterRule };
+export { BoldAnnotation, ComposeError, ComposedAnnotationFragment, CompositionStatistics, DiagnosticOrigin, DiagnosticSeverity, DisplayRange, EmphasisAnnotation, FontPreset, FontPresetId, FontSizePt, GraphemeRange, InvalidRuleOptions, ItalicAnnotation, LineOffset, ManuscriptAnnotation, ManuscriptAppearanceSettings, ManuscriptDiagnostic, ManuscriptGeometry, ManuscriptOffsets, ManuscriptRange, ManuscriptResult, NamespacedId, NovelCompositionSettings, NovelFlowSettings, NovelLayout, NovelLine, NovelPage, NovelStage, PaperSize, PaperSizeId, ParseError, ParsedGrapheme, ParsedManuscript, PositionedGrapheme, ProofreadError, ProofreadingReport, ProofreadingRuleMeta, Rejection, RubyAnnotation, RubyKind, RubyReading, SourcePosition, SourceRange, SuppressedGrapheme, TextRange, ValidationIssue, VerticalTextPresentation, assertNever, composeManuscript, consistentKanjiOpeningRule, consistentLatinWidthRule, consistentNumeralWidthRule, createConsistentKanjiOpeningRule, createDashRule, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createNovelComposer, createParagraphOpeningRule, dashRule, ellipsisCharacterRule, evenEllipsisRule, fullwidthJapanesePunctuationRule, kakuyomuParser, logicalInlineMeasurer, maxArabicNumeralDigitsRule, minusBeforeNumberRule, mmToPt, noConsecutiveInterpunctRule, noConsecutivePunctuationRule, novelComposer, paragraphOpeningRule, parseManuscript, pixivParser, plainTextParser, proofreadManuscript, ptToMm, punctuationBeforeClosingQuoteRule, spaceAfterQuestionOrExclamationRule, variantCharacterRule };