@sushichan044/kg-core 0.6.2 → 0.6.4

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 = () => 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()
+});
+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(),
+		baseAdvanceEm: emLength(),
+		readingGraphemes: readonlyArray(PositionedReadingGraphemeSchema),
+		...common$1
+	})
+]) };
 const LineOffset = {
 	schema: readonlyObject({
 		leading: nonNegativeInteger(),
@@ -1023,44 +1082,231 @@ 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)
+const InlineSpan = { schema: readonlyObject({
+	offsetEm: v.pipe(v.number(), v.finite()),
+	advanceEm: v.pipe(v.number(), v.finite(), v.minValue(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
 	}),
-	empty: () => ({
-		value: null,
-		range: null,
-		annotations: []
+	readonlyObject({
+		kind: v.literal("upright"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("sideways"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("tate-chu-yoko"),
+		...common
 	})
+]) };
+//#endregion
+//#region src/composer/composed-inline-item.ts
+const signedEm = () => v.pipe(v.number(), v.finite());
+const GlyphItemSchema = readonlyObject({
+	kind: v.literal("glyph"),
+	value: v.string(),
+	range: ManuscriptRange.schema,
+	layoutSpan: InlineSpan.schema,
+	renderSpan: InlineSpan.schema,
+	disposition: v.union([v.literal("placed"), v.literal("hanging")]),
+	presentation: VerticalTextPresentation.schema
+});
+const GeneratedGlueItemSchema = readonlyObject({
+	kind: v.literal("glue"),
+	origin: v.literal("generated"),
+	offsetEm: signedEm(),
+	widthEm: signedEm(),
+	naturalWidthEm: signedEm(),
+	adjustment: v.union([
+		v.literal("natural"),
+		v.literal("shrunk"),
+		v.literal("stretched")
+	])
+});
+const SourceGlueItemSchema = readonlyObject({
+	kind: v.literal("glue"),
+	origin: v.literal("source"),
+	value: v.string(),
+	range: ManuscriptRange.schema,
+	offsetEm: signedEm(),
+	widthEm: signedEm(),
+	naturalWidthEm: signedEm(),
+	adjustment: v.union([
+		v.literal("natural"),
+		v.literal("shrunk"),
+		v.literal("stretched")
+	])
+});
+const KernItemSchema = readonlyObject({
+	kind: v.literal("kern"),
+	offsetEm: signedEm(),
+	widthEm: signedEm()
+});
+const SuppressedItemSchema = readonlyObject({
+	kind: v.literal("suppressed"),
+	value: v.string(),
+	range: ManuscriptRange.schema,
+	reason: v.literal("question-or-exclamation-gap")
+});
+const ComposedInlineItem = { schema: v.union([
+	GlyphItemSchema,
+	GeneratedGlueItemSchema,
+	SourceGlueItemSchema,
+	KernItemSchema,
+	SuppressedItemSchema
+]) };
+const InlineMeasurement = { schema: readonlyObject({ advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0)) }) };
+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 { advanceEm: width / 2 };
+	return { advanceEm: request.presentation === "upright" ? [...graphemeSegmenter.segment(text)].length : width };
+};
+const LineBreakResult = { schema: v.variant("kind", [
+	readonlyObject({ kind: v.literal("natural") }),
+	readonlyObject({ kind: v.literal("shrunk") }),
+	readonlyObject({ kind: v.literal("stretched") }),
+	readonlyObject({ kind: v.literal("hanging") }),
+	readonlyObject({ kind: v.literal("forced") }),
+	readonlyObject({ kind: v.literal("paragraph-end") })
+]) };
+//#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 +1385,484 @@ 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/internal/japanese-typesetting-profile.ts
+const OPENING = /* @__PURE__ */ new Set(`${OPENING_BRACKETS}【〘〝｟«`);
+const CLOSING = /* @__PURE__ */ new Set(`${CLOSING_BRACKETS}】〙〟｠»`);
+const HYPHENS = /* @__PURE__ */ new Set("‐‑⁃–");
+const DIVIDING_PUNCTUATION = /* @__PURE__ */ new Set("！？‼⁇⁈⁉");
+const MIDDLE_DOTS = /* @__PURE__ */ new Set("・：；");
+const SMALL_KANA = /* @__PURE__ */ new Set("ァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖ");
+const ITERATION_MARKS = /* @__PURE__ */ new Set("ヽヾゝゞ々〻");
+const INSEPARABLE = /* @__PURE__ */ new Set("—―…‥─〳〵");
+const PREFIXED_ABBREVIATIONS = /* @__PURE__ */ new Set("￥＄£#＃");
+const POSTFIXED_ABBREVIATIONS = /* @__PURE__ */ new Set("°′″％‰");
+const UNIT_SYMBOLS = /* @__PURE__ */ new Set("℃℉㎀㎁㎂㎃㎄㎅㎆㎇㎈㎉㎊㎋㎌㎍㎎㎏㎐㎑㎒㎓㎔㎕㎖㎗㎘㎙㎚㎛㎜㎝㎞㎟㎠㎡㎢");
+const GROUPED_NUMERAL = /^[0-9０-９]$/u;
+const HIRAGANA = /^\p{Script=Hiragana}$/u;
+const KATAKANA = /^\p{Script=Katakana}$/u;
+const WESTERN = /^[\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}]$/u;
+function classify({ value, presentation }) {
+	if (presentation === "tate-chu-yoko") return "cl-30";
+	if (OPENING.has(value)) return "cl-01";
+	if (CLOSING.has(value)) return "cl-02";
+	if (HYPHENS.has(value)) return "cl-03";
+	if (DIVIDING_PUNCTUATION.has(value)) return "cl-04";
+	if (MIDDLE_DOTS.has(value)) return "cl-05";
+	if (value === "。" || value === "．") return "cl-06";
+	if (value === "、" || value === "，") return "cl-07";
+	if (INSEPARABLE.has(value)) return "cl-08";
+	if (ITERATION_MARKS.has(value)) return "cl-09";
+	if (value === "ー") return "cl-10";
+	if (SMALL_KANA.has(value)) return "cl-11";
+	if (PREFIXED_ABBREVIATIONS.has(value)) return "cl-12";
+	if (POSTFIXED_ABBREVIATIONS.has(value)) return "cl-13";
+	if (value === "　") return "cl-14";
+	if (HIRAGANA.test(value)) return "cl-15";
+	if (KATAKANA.test(value)) return "cl-16";
+	if (GROUPED_NUMERAL.test(value)) return "cl-24";
+	if (UNIT_SYMBOLS.has(value)) return "cl-25";
+	if (value === " ") return "cl-26";
+	if (WESTERN.test(value)) return "cl-27";
+	return "cl-19";
+}
+function pairSpacing(left, right) {
+	if (left === "cl-08" && right === "cl-08") return {
+		kind: "kern",
+		naturalWidthEm: 0
+	};
+	if (left === "cl-01" && right === "cl-01" || left === "cl-02" && right === "cl-02") return {
+		kind: "kern",
+		naturalWidthEm: -.5
+	};
+	if (left === "cl-07" || left === "cl-06") return {
+		kind: "glue",
+		naturalWidthEm: .5,
+		shrink: {
+			priority: 1,
+			amountEm: .5
+		}
+	};
+	if (left === "cl-02" || right === "cl-01") return {
+		kind: "glue",
+		naturalWidthEm: .5,
+		shrink: {
+			priority: 2,
+			amountEm: .5
+		}
+	};
+	return {
+		kind: "glue",
+		naturalWidthEm: 0,
+		stretch: {
+			priority: 3,
+			amountEm: .25
+		}
+	};
+}
+function breakPenalty(left, right) {
+	if (left === "cl-01" || left === "cl-12") return null;
+	if (right === "cl-02" || right === "cl-03" || right === "cl-04" || right === "cl-05" || right === "cl-06" || right === "cl-07" || right === "cl-09" || right === "cl-10" || right === "cl-11" || right === "cl-13") return null;
+	if (left === "cl-08" && right === "cl-08") return null;
+	return 0;
+}
+const defaultJapaneseTypesettingProfile = {
+	classify,
+	boxMetrics: (characterClass, measuredAdvanceEm) => ({
+		advanceEm: characterClass === "cl-01" || characterClass === "cl-02" || characterClass === "cl-06" || characterClass === "cl-07" ? Math.min(.5, measuredAdvanceEm) : measuredAdvanceEm,
+		renderOffsetEm: characterClass === "cl-01" ? -.5 : 0
+	}),
+	pairSpacing,
+	lineStartSpacing: (first) => first === "cl-01" ? {
+		kind: "glue",
+		naturalWidthEm: .5,
+		shrink: {
+			priority: 2,
+			amountEm: .5
+		}
+	} : null,
+	lineEndSpacing: (last) => last === "cl-02" || last === "cl-06" || last === "cl-07" ? {
+		kind: "glue",
+		naturalWidthEm: .5,
+		shrink: {
+			priority: 2,
+			amountEm: .5
+		}
+	} : null,
+	breakPenalty,
+	canHang: (characterClass) => characterClass === "cl-07" || characterClass === "cl-06"
+};
+//#endregion
+//#region src/composer/internal/paragraph-layout.ts
+const EPSILON = 1e-9;
+function skipSourceGaps(atoms, start) {
+	let cursor = start;
+	while (atoms[cursor]?.sourceGap === true) cursor += 1;
+	return cursor;
+}
+function previousVisible(atoms, end) {
+	for (let index = end - 1; index >= 0; index -= 1) if (atoms[index]?.sourceGap === false) return index;
+}
+function opportunities(atoms, classes, start, end, profile) {
+	const result = [];
+	const firstClass = classes[start];
+	const startSpacing = firstClass === void 0 ? null : profile.lineStartSpacing(firstClass);
+	if (startSpacing !== null) result.push({
+		boundary: start,
+		spacing: startSpacing
+	});
+	for (let right = start + 1; right < end; right += 1) {
+		const leftAtom = atoms[right - 1];
+		const rightAtom = atoms[right];
+		const leftClass = classes[right - 1];
+		const rightClass = classes[right];
+		if (leftAtom === void 0 || rightAtom === void 0 || leftClass === void 0 || rightClass === void 0 || leftAtom.sourceGap || rightAtom.sourceGap || !leftAtom.pairSpacingAfter) continue;
+		result.push({
+			boundary: right,
+			spacing: profile.pairSpacing(leftClass, rightClass)
+		});
+	}
+	const lastClass = classes[end - 1];
+	const endSpacing = lastClass === void 0 ? null : profile.lineEndSpacing(lastClass);
+	if (endSpacing !== null) result.push({
+		boundary: end,
+		spacing: endSpacing
+	});
+	return result;
+}
+function capacity(values, select) {
+	return values.reduce((total, opportunity) => total + (select(opportunity.spacing)?.amountEm ?? 0), 0);
+}
+function resolveSpacings(values, adjustment, amountEm) {
+	const remainingByBoundary = /* @__PURE__ */ new Map();
+	let remaining = amountEm;
+	let priorityCost = 0;
+	const capacities = values.flatMap((opportunity) => {
+		const selected = adjustment === "shrink" ? opportunity.spacing.shrink : opportunity.spacing.stretch;
+		return selected === void 0 ? [] : [{
+			...opportunity,
+			capacity: selected
+		}];
+	}).sort((left, right) => left.capacity.priority - right.capacity.priority || left.boundary - right.boundary);
+	for (const opportunity of capacities) {
+		if (remaining <= EPSILON) break;
+		const used = Math.min(remaining, opportunity.capacity.amountEm);
+		remainingByBoundary.set(opportunity.boundary, used);
+		priorityCost += used * opportunity.capacity.priority;
+		remaining -= used;
+	}
+	return {
+		spacings: values.map(({ boundary, spacing }) => {
+			const used = remainingByBoundary.get(boundary) ?? 0;
+			return {
+				boundary,
+				kind: spacing.kind,
+				naturalWidthEm: spacing.naturalWidthEm,
+				widthEm: adjustment === "shrink" ? spacing.naturalWidthEm - used : spacing.naturalWidthEm + used
+			};
+		}),
+		priorityCost
+	};
+}
+function candidate(atoms, classes, start, end, lineLengthEm, profile) {
+	const contentStart = skipSourceGaps(atoms, start);
+	const suppressedIndexes = Array.from({ length: contentStart - start }, (_, index) => start + index);
+	const pairValues = opportunities(atoms, classes, contentStart, end, profile);
+	const naturalSizeEm = atoms.slice(contentStart, end).reduce((total, atom) => total + atom.boxAdvanceEm, 0) + pairValues.reduce((total, value) => total + value.spacing.naturalWidthEm, 0);
+	const terminal = skipSourceGaps(atoms, end) === atoms.length;
+	const shrinkCapacity = capacity(pairValues, ({ shrink }) => shrink);
+	const stretchCapacity = capacity(pairValues, ({ stretch }) => stretch);
+	const overflow = naturalSizeEm - lineLengthEm;
+	const underflow = lineLengthEm - naturalSizeEm;
+	const lastVisible = previousVisible(atoms, end);
+	const lastClass = lastVisible === void 0 ? void 0 : classes[lastVisible];
+	const lastAdvance = lastVisible === void 0 ? 0 : atoms[lastVisible]?.boxAdvanceEm ?? 0;
+	const trailingSpacing = pairValues.find(({ boundary }) => boundary === end)?.spacing.naturalWidthEm ?? 0;
+	if (terminal && overflow <= EPSILON) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		inlineSizeEm: naturalSizeEm,
+		break: { kind: "paragraph-end" },
+		hangingIndex: null,
+		deformationRatio: 0,
+		priorityCost: 0
+	};
+	if (Math.abs(overflow) <= EPSILON) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		inlineSizeEm: naturalSizeEm,
+		break: { kind: "natural" },
+		hangingIndex: null,
+		deformationRatio: 0,
+		priorityCost: 0
+	};
+	if (overflow > 0 && overflow <= shrinkCapacity + EPSILON) {
+		const resolved = resolveSpacings(pairValues, "shrink", overflow);
+		return {
+			start,
+			contentStart,
+			end,
+			suppressedIndexes,
+			pairSpacings: resolved.spacings,
+			inlineSizeEm: lineLengthEm,
+			break: { kind: "shrunk" },
+			hangingIndex: null,
+			deformationRatio: shrinkCapacity === 0 ? 0 : overflow / shrinkCapacity,
+			priorityCost: resolved.priorityCost
+		};
+	}
+	if (!terminal && overflow > 0 && lastVisible !== void 0 && lastClass !== void 0 && profile.canHang(lastClass) && naturalSizeEm - lastAdvance - trailingSpacing <= lineLengthEm + EPSILON) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings.filter(({ boundary }) => boundary !== end),
+		inlineSizeEm: naturalSizeEm - lastAdvance - trailingSpacing,
+		break: { kind: "hanging" },
+		hangingIndex: lastVisible,
+		deformationRatio: overflow / Math.max(lastAdvance, EPSILON),
+		priorityCost: 0
+	};
+	if (!terminal && underflow > EPSILON && underflow <= stretchCapacity + EPSILON) {
+		const resolved = resolveSpacings(pairValues, "stretch", underflow);
+		return {
+			start,
+			contentStart,
+			end,
+			suppressedIndexes,
+			pairSpacings: resolved.spacings,
+			inlineSizeEm: lineLengthEm,
+			break: { kind: "stretched" },
+			hangingIndex: null,
+			deformationRatio: stretchCapacity === 0 ? 0 : underflow / stretchCapacity,
+			priorityCost: resolved.priorityCost
+		};
+	}
+	return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		inlineSizeEm: naturalSizeEm,
+		break: { kind: "forced" },
+		hangingIndex: null,
+		deformationRatio: Math.abs(naturalSizeEm - lineLengthEm) / Math.max(lineLengthEm, EPSILON),
+		priorityCost: 0
+	};
+}
+function scoreFor(line, previousFitness) {
+	const mode = line.break.kind;
+	const fitness = Math.min(3, Math.floor(line.deformationRatio * 4));
+	const transition = Math.abs(previousFitness - fitness) > 1 ? 1 : 0;
+	const modeCounts = {
+		forced: mode === "forced" ? 1 : 0,
+		stretched: mode === "stretched" ? 1 : 0,
+		hanging: mode === "hanging" ? 1 : 0,
+		shrunk: mode === "shrunk" ? 1 : 0
+	};
+	return {
+		score: [
+			modeCounts.forced,
+			modeCounts.stretched,
+			modeCounts.hanging,
+			modeCounts.shrunk,
+			line.priorityCost,
+			line.deformationRatio ** 3,
+			transition
+		],
+		fitness
+	};
+}
+function addScore(left, right) {
+	return [
+		left[0] + right[0],
+		left[1] + right[1],
+		left[2] + right[2],
+		left[3] + right[3],
+		left[4] + right[4],
+		left[5] + right[5],
+		left[6] + right[6]
+	];
+}
+function compareBreaks(left, right) {
+	const length = Math.min(left.length, right.length);
+	for (let index = 0; index < length; index += 1) {
+		const difference = (right[index] ?? 0) - (left[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return left.length - right.length;
+}
+function isBetter(candidateState, current) {
+	if (current === void 0) return true;
+	for (let index = 0; index < candidateState.score.length; index += 1) {
+		const difference = (candidateState.score[index] ?? 0) - (current.score[index] ?? 0);
+		if (Math.abs(difference) > EPSILON) return difference < 0;
+	}
+	return compareBreaks(candidateState.breaks, current.breaks) < 0;
+}
+function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
+	if (atoms.length === 0) return [];
+	const classes = atoms.map(({ characterClass }) => characterClass);
+	const states = /* @__PURE__ */ new Map([[0, /* @__PURE__ */ new Map([[0, {
+		score: [
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		],
+		fitness: 0,
+		previous: null,
+		line: null,
+		breaks: []
+	}]])]]);
+	for (let start = 0; start < atoms.length; start += 1) {
+		const activeStates = states.get(start);
+		if (activeStates === void 0) continue;
+		const contentStart = skipSourceGaps(atoms, start);
+		if (contentStart === atoms.length) {
+			const terminalStates = states.get(atoms.length) ?? /* @__PURE__ */ new Map();
+			for (const state of activeStates.values()) if (isBetter(state, terminalStates.get(state.fitness))) terminalStates.set(state.fitness, state);
+			states.set(atoms.length, terminalStates);
+			continue;
+		}
+		for (const state of activeStates.values()) for (let end = contentStart + 1; end <= atoms.length; end += 1) {
+			const right = skipSourceGaps(atoms, end);
+			const left = previousVisible(atoms, end);
+			if (atoms[end - 1]?.sourceGap === true) continue;
+			if (end < atoms.length && right < atoms.length && (left === void 0 || !boundaryAllowed(left, right))) continue;
+			const line = candidate(atoms, classes, start, end, lineLengthEm, profile);
+			if (line.break.kind === "forced" && line.inlineSizeEm > lineLengthEm + EPSILON && Array.from({ length: end - contentStart - 1 }, (_, index) => contentStart + index + 1).some((boundary) => boundaryAllowed(boundary - 1, boundary))) {
+				if (line.inlineSizeEm > lineLengthEm * 2 && end > contentStart + 1) break;
+				continue;
+			}
+			const lineScore = scoreFor(line, state.fitness);
+			const nextState = {
+				score: addScore(state.score, lineScore.score),
+				fitness: lineScore.fitness,
+				previous: {
+					index: start,
+					fitness: state.fitness
+				},
+				line,
+				breaks: [...state.breaks, end]
+			};
+			const statesAtEnd = states.get(end) ?? /* @__PURE__ */ new Map();
+			if (isBetter(nextState, statesAtEnd.get(nextState.fitness))) {
+				statesAtEnd.set(nextState.fitness, nextState);
+				states.set(end, statesAtEnd);
+			}
+			if (line.inlineSizeEm > lineLengthEm * 2 && line.break.kind === "forced" && end > contentStart + 1) break;
+		}
+	}
+	const terminal = [...states.get(atoms.length)?.values() ?? []].reduce((best, state) => isBetter(state, best) ? state : best, void 0);
+	if (terminal === void 0) return [];
+	const lines = [];
+	let cursor = terminal;
+	while (cursor?.line !== null && cursor?.line !== void 0) {
+		lines.push(cursor.line);
+		cursor = cursor.previous === null ? void 0 : states.get(cursor.previous.index)?.get(cursor.previous.fitness);
+	}
+	lines.reverse();
+	const last = lines.at(-1);
+	if (last !== void 0 && last.end < atoms.length) lines[lines.length - 1] = {
+		...last,
+		suppressedIndexes: [...last.suppressedIndexes, ...Array.from({ length: atoms.length - last.end }, (_, index) => last.end + index)]
+	};
+	return lines;
+}
+const NovelLine = {
 	schema: readonlyObject({
 		range: v.nullable(ManuscriptRange.schema),
-		cells: readonlyArray(GridCell.schema)
+		inlineSizeEm: v.pipe(v.number(), v.finite(), v.minValue(0)),
+		items: readonlyArray(ComposedInlineItem.schema),
+		break: LineBreakResult.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,
+		inlineSizeEm: 0,
+		items: [],
+		break: { kind: "paragraph-end" },
+		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 TYPESETTING_PROFILE = defaultJapaneseTypesettingProfile;
+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 +1872,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 +1889,345 @@ 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)];
-	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;
+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 measurement = role === "base" ? measurer({
+		...context,
+		role,
+		presentation: presentationKind ?? "mixed"
+	}) : measurer({
+		...context,
+		role
+	});
+	const parsed = v.safeParse(InlineMeasurement.schema, measurement);
+	if (!parsed.success) return void 0;
+	const { advanceEm } = parsed.output;
+	return advanceEm;
+}
+function measureSourceLine(sourceLine, annotations, settings, measurer) {
+	const mutable = presentedSourceLine(sourceLine).map(({ grapheme, presentation }) => {
+		const renderAdvanceEm = measure(measurer, grapheme.value, "base", settings, presentation.kind);
+		if (renderAdvanceEm === void 0) return void 0;
+		const characterClass = TYPESETTING_PROFILE.classify({
+			value: grapheme.value,
+			presentation: presentation.kind
+		});
+		const metrics = TYPESETTING_PROFILE.boxMetrics(characterClass, renderAdvanceEm);
+		return {
+			grapheme,
+			boxAdvanceEm: metrics.advanceEm,
+			renderAdvanceEm,
+			renderOffsetEm: metrics.renderOffsetEm,
+			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]?.boxAdvanceEm ?? 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.boxAdvanceEm += 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.boxAdvanceEm = Math.max(atom.boxAdvanceEm, readingAdvance);
+		}
 	}
-	return lines;
+	return {
+		atoms,
+		suppressedIndexes: validGapIndexes(sourceLine)
+	};
 }
-function blankLines(count, charsPerLine) {
-	return Array.from({ length: count }, () => GridLine.padded([], charsPerLine));
+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]?.boxAdvanceEm ?? 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, leftIndex, rightIndex, lineLengthEm, profile) {
+	const left = atoms[leftIndex];
+	const right = atoms[rightIndex];
+	if (left === void 0 || right === void 0) return true;
+	return !samePresentationGroup(left, right) && profile.breakPenalty(profile.classify({
+		value: left.grapheme.value,
+		presentation: left.presentation.kind
+	}), profile.classify({
+		value: right.grapheme.value,
+		presentation: right.presentation.kind
+	})) !== null && !breakInsideFittableGroupRuby(atoms, annotations, rightIndex, 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, sourceGlues, 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),
+		...sourceGlues.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range)
+	]);
+}
+function annotationFragments(graphemes, suppressed, sourceGlues, 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, sourceGlues, 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.layoutSpan.offsetEm;
+				const baseAdvanceEm = last.layoutSpan.offsetEm + last.layoutSpan.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, sourceGapIndexes, plan) {
+	const items = plan.suppressedIndexes.flatMap((index) => {
+		const atom = atoms[index];
+		return atom === void 0 ? [] : [{
+			kind: "suppressed",
+			value: atom.grapheme.value,
+			range: atom.grapheme.range,
+			reason: "question-or-exclamation-gap"
+		}];
+	});
+	const spacings = new Map(plan.pairSpacings.map((spacing) => [spacing.boundary, spacing]));
+	let offsetEm = 0;
+	const positionSpacing = (spacing) => {
+		if (spacing.kind === "kern") items.push({
+			kind: "kern",
+			offsetEm,
+			widthEm: spacing.widthEm
+		});
+		else items.push({
+			kind: "glue",
+			origin: "generated",
+			offsetEm,
+			widthEm: spacing.widthEm,
+			naturalWidthEm: spacing.naturalWidthEm,
+			adjustment: spacing.widthEm < spacing.naturalWidthEm ? "shrunk" : spacing.widthEm > spacing.naturalWidthEm ? "stretched" : "natural"
+		});
+		offsetEm += spacing.widthEm;
+	};
+	for (let index = plan.contentStart; index < plan.end; index += 1) {
+		const spacing = spacings.get(index);
+		if (spacing !== void 0) positionSpacing(spacing);
+		const atom = atoms[index];
+		if (atom === void 0) continue;
+		if (sourceGapIndexes.has(index)) {
+			items.push({
+				kind: "glue",
+				origin: "source",
+				value: atom.grapheme.value,
+				range: atom.grapheme.range,
+				offsetEm,
+				widthEm: atom.boxAdvanceEm,
+				naturalWidthEm: atom.boxAdvanceEm,
+				adjustment: "natural"
+			});
+			offsetEm += atom.boxAdvanceEm;
+			continue;
+		}
+		const hanging = plan.hangingIndex === index;
+		const layoutAdvanceEm = hanging ? 0 : atom.boxAdvanceEm;
+		items.push({
+			kind: "glyph",
+			value: atom.grapheme.value,
+			range: atom.grapheme.range,
+			layoutSpan: {
+				offsetEm,
+				advanceEm: layoutAdvanceEm
+			},
+			renderSpan: {
+				offsetEm: offsetEm + atom.renderOffsetEm,
+				advanceEm: atom.renderAdvanceEm
+			},
+			disposition: hanging ? "hanging" : "placed",
+			presentation: atom.presentation
+		});
+		offsetEm += layoutAdvanceEm;
+	}
+	const trailingSpacing = spacings.get(plan.end);
+	if (trailingSpacing !== void 0) positionSpacing(trailingSpacing);
+	const ranges = items.flatMap((item) => item.kind === "glyph" || item.kind === "suppressed" || item.kind === "glue" && item.origin === "source" ? [item.range] : []);
+	return {
+		range: ManuscriptRange.merge(ranges),
+		inlineSizeEm: Math.max(0, plan.inlineSizeEm),
+		items,
+		break: plan.break,
+		annotations: []
+	};
+}
+function wrapSourceLine(sourceLine, annotations, settings, measurer, baseAdvances) {
+	if (sourceLine.atoms.length === 0) return [NovelLine.empty()];
+	const profile = TYPESETTING_PROFILE;
+	const lines = layoutParagraph(sourceLine.atoms.map(({ grapheme, boxAdvanceEm, presentation }, index) => {
+		const current = sourceLine.atoms[index];
+		const next = sourceLine.atoms[index + 1];
+		return {
+			value: grapheme.value,
+			boxAdvanceEm,
+			sourceGap: sourceLine.suppressedIndexes.has(index),
+			characterClass: profile.classify({
+				value: grapheme.value,
+				presentation: presentation.kind
+			}),
+			pairSpacingAfter: current === void 0 || next === void 0 || !samePresentationGroup(current, next) && !breakInsideFittableGroupRuby(sourceLine.atoms, annotations, index + 1, settings.flow.lineLengthEm)
+		};
+	}), settings.flow.lineLengthEm, profile, (leftIndex, rightIndex) => legalBoundary(sourceLine.atoms, annotations, leftIndex, rightIndex, settings.flow.lineLengthEm, profile)).map((plan) => positionedLine(sourceLine.atoms, sourceLine.suppressedIndexes, plan));
+	const fragmentPlansByAnnotation = new Map(annotations.map((annotation) => {
+		const ranges = lines.flatMap((line) => {
+			const range = annotationFragmentRange(line.items.filter((item) => item.kind === "glyph"), line.items.filter((item) => item.kind === "suppressed"), line.items.flatMap((item) => item.kind === "glue" && item.origin === "source" ? [item] : []), annotation);
+			return range === null ? [] : [range];
+		});
+		return [annotation, {
+			ranges,
+			groupReadings: annotation.kind === "ruby" ? groupReadingsForFragments(annotation, ranges, baseAdvances) : []
+		}];
+	}));
+	return lines.map((line) => ({
+		range: line.range,
+		inlineSizeEm: line.inlineSizeEm,
+		items: line.items,
+		break: line.break,
+		annotations: annotationFragments(line.items.filter((item) => item.kind === "glyph"), line.items.filter((item) => item.kind === "suppressed"), line.items.flatMap((item) => item.kind === "glue" && item.origin === "source" ? [item] : []), annotations, settings, measurer, fragmentPlansByAnnotation)
+	}));
+}
+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 +2243,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.boxAdvanceEm);
+		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 +3033,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, ComposedInlineItem, CompositionStatistics, DiagnosticOrigin, DiagnosticSeverity, DisplayRange, EmphasisAnnotation, FontPreset, FontPresetId, FontSizePt, GraphemeRange, InlineMeasurement, InlineSpan, InvalidRuleOptions, ItalicAnnotation, LineBreakResult, LineOffset, ManuscriptAnnotation, ManuscriptAppearanceSettings, ManuscriptDiagnostic, ManuscriptGeometry, ManuscriptOffsets, ManuscriptRange, ManuscriptResult, NamespacedId, NovelCompositionSettings, NovelFlowSettings, NovelLayout, NovelLine, NovelPage, NovelStage, PaperSize, PaperSizeId, ParseError, ParsedGrapheme, ParsedManuscript, ProofreadError, ProofreadingReport, ProofreadingRuleMeta, Rejection, RubyAnnotation, RubyKind, RubyReading, SourcePosition, SourceRange, 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 };