@sushichan044/kg-core 0.6.2 → 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,44 +1082,143 @@ 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: []
-	})
+//#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
+const STAGE_GAP_CELLS = 2;
+const LINE_GAP_CELLS = .5;
+const nonNegativeLength = () => v.pipe(v.number(), v.finite(), v.minValue(0));
+const ManuscriptGeometrySchema = readonlyObject({
+	paperWidthMm: nonNegativeLength(),
+	paperHeightMm: nonNegativeLength(),
+	cellSizeMm: nonNegativeLength(),
+	lineGapMm: nonNegativeLength(),
+	fontSizePt: FontSizePt.schema,
+	contentWidthMm: nonNegativeLength(),
+	contentHeightMm: nonNegativeLength(),
+	marginInlineMm: v.pipe(v.number(), v.finite()),
+	marginBlockMm: v.pipe(v.number(), v.finite()),
+	fitsPaper: v.boolean()
+});
+/**
+* Every stage stacked vertically, plus the gap between adjacent stages.
+*/
+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 contentWidthInEm(flow) {
+	return flow.linesPerStage + LINE_GAP_CELLS * (flow.linesPerStage - 1);
+}
+const ManuscriptGeometry = {
+	schema: ManuscriptGeometrySchema,
+	of: (flow, appearance) => {
+		const paper = PaperSize.of(appearance.paperSize);
+		const cellSizeMm = ptToMm(appearance.fontSizePt);
+		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,
+			contentWidthMm,
+			contentHeightMm,
+			marginInlineMm,
+			marginBlockMm,
+			fitsPaper: marginInlineMm >= 0 && marginBlockMm >= 0
+		};
+	},
+	/**
+	* The largest step-aligned point size whose text area still fits the paper.
+	*/
+	maxFontSizePt: (flow, paperSizeId) => {
+		const paper = PaperSize.of(paperSizeId);
+		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));
+	}
 };
 //#endregion
 //#region src/internal/japanese-brackets.ts
@@ -1139,113 +1297,136 @@ function analyzeMatch(line, marks) {
 function questionOrExclamationSpacings(line) {
 	return [...line.matchAll(MARKS)].map((marks) => analyzeMatch(line, marks)).filter((spacing) => spacing !== void 0);
 }
-const GridLine = {
+//#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),
-		cells: readonlyArray(GridCell.schema)
+		advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0)),
+		graphemes: readonlyArray(PositionedGrapheme.schema),
+		suppressed: readonlyArray(SuppressedGrapheme.schema),
+		annotations: readonlyArray(ComposedAnnotationFragment.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)])
+	empty: () => ({
+		range: null,
+		advanceEm: 0,
+		graphemes: [],
+		suppressed: [],
+		annotations: []
+	})
 };
-const GridStage = {
+const NovelStage = {
 	schema: readonlyObject({
 		range: v.nullable(ManuscriptRange.schema),
-		lines: readonlyArray(GridLine.schema)
+		lines: readonlyArray(NovelLine.schema)
 	}),
 	of: (lines) => ({
 		lines,
 		range: ManuscriptRange.merge(lines.map(({ range }) => range))
 	})
 };
-const GridPage = {
+const NovelPage = {
 	schema: readonlyObject({
 		range: v.nullable(ManuscriptRange.schema),
-		stages: readonlyArray(GridStage.schema)
+		stages: readonlyArray(NovelStage.schema)
 	}),
 	of: (stages) => ({
 		stages,
 		range: ManuscriptRange.merge(stages.map(({ range }) => range))
 	})
 };
-//#endregion
-//#region src/composer/manuscript-geometry.ts
-const STAGE_GAP_CELLS = 2;
-const LINE_GAP_CELLS = .5;
-const nonNegativeLength = () => v.pipe(v.number(), v.finite(), v.minValue(0));
-const ManuscriptGeometrySchema = readonlyObject({
-	paperWidthMm: nonNegativeLength(),
-	paperHeightMm: nonNegativeLength(),
-	cellSizeMm: nonNegativeLength(),
-	lineGapMm: nonNegativeLength(),
-	fontSizePt: FontSizePt.schema,
-	gridWidthMm: nonNegativeLength(),
-	gridHeightMm: nonNegativeLength(),
-	marginInlineMm: v.pipe(v.number(), v.finite()),
-	marginBlockMm: v.pipe(v.number(), v.finite()),
-	fitsPaper: v.boolean()
-});
-/**
-* Every stage stacked vertically, plus the gap between adjacent stages.
-*/
-function gridHeightInCells(grid) {
-	return grid.stagesPerPage * grid.charsPerLine + STAGE_GAP_CELLS * (grid.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);
-}
-const ManuscriptGeometry = {
-	schema: ManuscriptGeometrySchema,
-	of: (grid, 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;
-		return {
-			paperWidthMm: paper.widthMm,
-			paperHeightMm: paper.heightMm,
-			cellSizeMm,
-			lineGapMm: LINE_GAP_CELLS * cellSizeMm,
-			fontSizePt: appearance.fontSizePt,
-			gridWidthMm,
-			gridHeightMm,
-			marginInlineMm,
-			marginBlockMm,
-			fitsPaper: marginInlineMm >= 0 && marginBlockMm >= 0
-		};
-	},
-	/**
-	* The largest step-aligned point size whose grid still fits the paper, clamped to the range.
-	*/
-	maxFontSizePt: (grid, paperSizeId) => {
-		const paper = PaperSize.of(paperSizeId);
-		const maxCellSizeMm = Math.min(paper.widthMm / gridWidthInCells(grid), paper.heightMm / gridHeightInCells(grid));
-		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),
+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;
@@ -1255,20 +1436,13 @@ 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 hangingGapIndexes(sourceLine) {
+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();
@@ -1279,31 +1453,309 @@ function hangingGapIndexes(sourceLine) {
 	}
 	return indexes;
 }
-/**
-* Wraps one source line across as many grid lines as its length requires. A valid gap after ！ or ？
-* that would start a wrapped line is consumed as hanging punctuation instead of occupying a cell.
-*/
-function wrapLine(cells, charsPerLine, hangingGaps) {
-	if (cells.length === 0) return [GridLine.padded([], charsPerLine)];
+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;
+	});
+}
+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 < cells.length) {
-		if (lines.length > 0 && hangingGaps.has(cursor)) cursor += 1;
-		if (cursor >= cells.length) break;
-		lines.push(GridLine.padded(cells.slice(cursor, cursor + charsPerLine), charsPerLine));
-		cursor += charsPerLine;
+	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;
 	}
-	return lines;
+	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;
@@ -1319,47 +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 manuscriptLines = sourceLines.flatMap((line) => wrapLine(toCells(line, manuscript.annotations), charsPerLine, hangingGapIndexes(line)));
-	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: sourceLines.reduce((total, line) => total + line.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(", ")}` };
@@ -2105,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 };