@sushichan044/kg-core 0.9.1 → 0.9.3

package/README.md

@@ -81,8 +81,11 @@ The composer classifies the core prose classes from JLReq, resolves pair spacing
 and selects line breaks over the whole source paragraph. The space between two
 classes follows appendix 表1 of JLReq: a half em before an opening bracket and after
 a closing bracket, comma, or full stop, a quarter em on either side of a middle dot,
-a quarter em between Japanese and a numeral, unit symbol, or Western character, and
-solid where two of those punctuation marks meet.
+a quarter em between Japanese and a numeral, unit symbol, or a Western character rotated
+90 degrees or mixed into horizontal text, and solid where two of those punctuation marks
+meet. JLReq 3.2.4 sets that quarter em's scope: a Western character set upright — one letter,
+an all-caps or `Xxx` abbreviation, a lone digit, or a full-width letter — classes with kanji
+instead and sits solid against the kana or kanji beside it, the same as a tate-chu-yoko run.
 
 A western word space is not a character with a box but an アキ of its own: a third em
 by rule rather than by measurement, nothing at all at a line head or a line end, and
@@ -95,9 +98,15 @@ stage, or by hanging a comma or full stop; a short line is answered by opening u
 where JLReq 3.8.4 and appendix 表6
 allow it — the word space first, up to a half, then the Japanese-to-Western quarter em,
 also up to a half, then a solid pair between kana, kanji, and the marks that go with
-them, up to a quarter. Space around
-brackets, commas, full stops, middle dots, hyphens, and an ideographic space is never
-opened up. A line that admits none of these is forced. The choice is made for the
+them, up to a quarter. If those stages cannot fill the line, the remaining width is
+added equally to the admitted pairs in 表6 that are solid at rest, including pairs used by
+the third stage. Intrinsic spaces keep their finite limits: a word space and a mixed
+Japanese-to-Western, numeral, or unit-symbol gap stop at a half em, while punctuation and
+explicit full-em spaces retain their own width. This keeps the unbounded stage from producing
+double space or a hole disproportionate to a horizontal Western run's own length, since an
+upright Western run classes with kanji and has no gap of its own to begin with.
+Line-head and line-end space, inseparable pairs, and source-authored full-em gaps after
+question or exclamation marks stay fixed. A line with no admitted gap is forced. The choice is made for the
 paragraph rather than line by line,
 minimizing in order the number of forced lines, then stretched, then hanging, then
 shrunk lines that spent visible space. Which space may be reduced, and in which
@@ -140,6 +149,11 @@ words remain unbroken and render sideways, and two ASCII digits form one
 tate-chu-yoko unit. The resulting `VerticalTextPresentation` is carried by every
 glyph item, so renderers do not need to infer orientation independently.
 
+An upright Western character sets solid against the kana or kanji beside it rather than
+taking the quarter em 3.2.6 puts around a sideways run, following JLReq 3.2.4: it classes
+with kanji, the same way 3.2.5 classes a tate-chu-yoko run. `QR` and `URL` set upright by
+this rule read flush against their surrounding Japanese text, the way a kanji compound does.
+
 The default logical measurer uses East Asian Width in a Japanese context. Upright
 ASCII advances by one em; proportional ASCII and the members of a tate-chu-yoko unit
 advance by half an em. Supply a synchronous measurer when the caller has more accurate

package/dist/{composed-manuscript-QgIdae8p.d.mts → composed-manuscript-C0f3mxKs.d.mts}

@@ -914,7 +914,7 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
     }>;
     mark: string;
   }>]>], undefined>, undefined>, v.ReadonlyAction<(Readonly<{
-    kind: "ruby";
+    kind: "italic";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -929,18 +929,8 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
         end: number;
       }> & v.Brand<"GraphemeRange">;
     }>;
-    reading: Readonly<{
-      kind: "group";
-      text: string;
-    }> | Readonly<{
-      kind: "mono";
-      readonly segments: readonly string[];
-    }> | Readonly<{
-      kind: "jukugo";
-      readonly segments: readonly string[];
-    }>;
   }> | Readonly<{
-    kind: "bold";
+    kind: "ruby";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -955,8 +945,18 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
         end: number;
       }> & v.Brand<"GraphemeRange">;
     }>;
+    reading: Readonly<{
+      kind: "group";
+      text: string;
+    }> | Readonly<{
+      kind: "mono";
+      readonly segments: readonly string[];
+    }> | Readonly<{
+      kind: "jukugo";
+      readonly segments: readonly string[];
+    }>;
   }> | Readonly<{
-    kind: "italic";
+    kind: "bold";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -1010,7 +1010,7 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
     }>;
   }>[];
   readonly annotations: readonly (Readonly<{
-    kind: "ruby";
+    kind: "italic";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -1025,18 +1025,8 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
         end: number;
       }> & v.Brand<"GraphemeRange">;
     }>;
-    reading: Readonly<{
-      kind: "group";
-      text: string;
-    }> | Readonly<{
-      kind: "mono";
-      readonly segments: readonly string[];
-    }> | Readonly<{
-      kind: "jukugo";
-      readonly segments: readonly string[];
-    }>;
   }> | Readonly<{
-    kind: "bold";
+    kind: "ruby";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -1051,8 +1041,18 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
         end: number;
       }> & v.Brand<"GraphemeRange">;
     }>;
+    reading: Readonly<{
+      kind: "group";
+      text: string;
+    }> | Readonly<{
+      kind: "mono";
+      readonly segments: readonly string[];
+    }> | Readonly<{
+      kind: "jukugo";
+      readonly segments: readonly string[];
+    }>;
   }> | Readonly<{
-    kind: "italic";
+    kind: "bold";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -1503,7 +1503,7 @@ declare const ParsedManuscript: {
       }>;
       mark: string;
     }>]>], undefined>, undefined>, v.ReadonlyAction<(Readonly<{
-      kind: "ruby";
+      kind: "italic";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;
@@ -1518,18 +1518,8 @@ declare const ParsedManuscript: {
           end: number;
         }> & v.Brand<"GraphemeRange">;
       }>;
-      reading: Readonly<{
-        kind: "group";
-        text: string;
-      }> | Readonly<{
-        kind: "mono";
-        readonly segments: readonly string[];
-      }> | Readonly<{
-        kind: "jukugo";
-        readonly segments: readonly string[];
-      }>;
     }> | Readonly<{
-      kind: "bold";
+      kind: "ruby";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;
@@ -1544,8 +1534,18 @@ declare const ParsedManuscript: {
           end: number;
         }> & v.Brand<"GraphemeRange">;
       }>;
+      reading: Readonly<{
+        kind: "group";
+        text: string;
+      }> | Readonly<{
+        kind: "mono";
+        readonly segments: readonly string[];
+      }> | Readonly<{
+        kind: "jukugo";
+        readonly segments: readonly string[];
+      }>;
     }> | Readonly<{
-      kind: "italic";
+      kind: "bold";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;
@@ -1599,7 +1599,7 @@ declare const ParsedManuscript: {
       }>;
     }>[];
     readonly annotations: readonly (Readonly<{
-      kind: "ruby";
+      kind: "italic";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;
@@ -1614,18 +1614,8 @@ declare const ParsedManuscript: {
           end: number;
         }> & v.Brand<"GraphemeRange">;
       }>;
-      reading: Readonly<{
-        kind: "group";
-        text: string;
-      }> | Readonly<{
-        kind: "mono";
-        readonly segments: readonly string[];
-      }> | Readonly<{
-        kind: "jukugo";
-        readonly segments: readonly string[];
-      }>;
     }> | Readonly<{
-      kind: "bold";
+      kind: "ruby";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;
@@ -1640,8 +1630,18 @@ declare const ParsedManuscript: {
           end: number;
         }> & v.Brand<"GraphemeRange">;
       }>;
+      reading: Readonly<{
+        kind: "group";
+        text: string;
+      }> | Readonly<{
+        kind: "mono";
+        readonly segments: readonly string[];
+      }> | Readonly<{
+        kind: "jukugo";
+        readonly segments: readonly string[];
+      }>;
     }> | Readonly<{
-      kind: "italic";
+      kind: "bold";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { a as ManuscriptResult, c as DiagnosticSeverity, d as ManuscriptRangeInput, i as ParsedManuscript, l as DiagnosticOrigin, n as ValidationIssue, o as ManuscriptDiagnostic, r as NamespacedId, s as ManuscriptDiagnosticInput, t as ComposedManuscript, u as ManuscriptRange } from "./composed-manuscript-QgIdae8p.mjs";
-import { d as NovelCompositionSettings, f as ManuscriptComposer, i as NovelLayout, l as VerticalTextPresentation, p as ManuscriptParser, r as novelComposer, t as NovelComposedManuscript, u as FontPresetId } from "./novel-composer-BCt9g172.mjs";
+import { a as ManuscriptResult, c as DiagnosticSeverity, d as ManuscriptRangeInput, i as ParsedManuscript, l as DiagnosticOrigin, n as ValidationIssue, o as ManuscriptDiagnostic, r as NamespacedId, s as ManuscriptDiagnosticInput, t as ComposedManuscript, u as ManuscriptRange } from "./composed-manuscript-C0f3mxKs.mjs";
+import { d as NovelCompositionSettings, f as ManuscriptComposer, i as NovelLayout, l as VerticalTextPresentation, p as ManuscriptParser, r as novelComposer, t as NovelComposedManuscript, u as FontPresetId } from "./novel-composer-DhycV9B3.mjs";
 import * as v from "valibot";
 //#region src/parser/parse-error.d.ts
 /**

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { c as ManuscriptResult, d as NamespacedId, f as ManuscriptRange, h as readonlyObject, l as ManuscriptDiagnostic, o as graphemeSegmenter, s as ValidationIssue } from "./question-or-exclamation-spacing-B5o23ZLf.mjs";
-import { c as ManuscriptOffsets, d as FontSizePt, f as FontPresetId, i as PaperSize, l as ManuscriptAppearanceSettings, n as novelComposer, o as NovelCompositionSettings, p as ParsedManuscript, r as ManuscriptGeometry, s as NovelFlowSettings, u as PaperSizeId } from "./novel-composer-CtovfhET.mjs";
+import { c as ManuscriptOffsets, d as FontSizePt, f as FontPresetId, i as PaperSize, l as ManuscriptAppearanceSettings, n as novelComposer, o as NovelCompositionSettings, p as ParsedManuscript, r as ManuscriptGeometry, s as NovelFlowSettings, u as PaperSizeId } from "./novel-composer-DRgsEA2s.mjs";
 import { n as assertNever, t as describeCause } from "./describe-cause-BV8mZ3Um.mjs";
 import * as v from "valibot";
 const Rejection = { schema: readonlyObject({ reason: v.string() }) };

package/dist/lint.d.mts

@@ -1,4 +1,4 @@
-import { a as ManuscriptResult, i as ParsedManuscript, n as ValidationIssue, o as ManuscriptDiagnostic, r as NamespacedId, t as ComposedManuscript } from "./composed-manuscript-QgIdae8p.mjs";
+import { a as ManuscriptResult, i as ParsedManuscript, n as ValidationIssue, o as ManuscriptDiagnostic, r as NamespacedId, t as ComposedManuscript } from "./composed-manuscript-C0f3mxKs.mjs";
 import * as v from "valibot";
 //#region src/proofreading/invalid-rule-options.d.ts
 /**

package/dist/{novel-composer-CtovfhET.mjs → novel-composer-DRgsEA2s.mjs}

@@ -306,11 +306,19 @@ const HIRAGANA = /^\p{Script=Hiragana}$/u;
 const KATAKANA = /^\p{Script=Katakana}$/u;
 const WESTERN = /^[\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}]$/u;
 /**
-* Order matters: a character inside a tate-chu-yoko group is cl-30 whatever it would be on its own,
-* and anything left unmatched is cl-19, the class JLReq reserves for kanji and the like.
+* Order matters: a character inside a tate-chu-yoko group is cl-30 (3.2.5) and an upright Latin
+* letter or Arabic numeral is cl-19 (3.2.4), whatever either would be on its own; anything left
+* unmatched is cl-19 too, the class JLReq reserves for kanji and the like.
+*
+* The quarter em 3.2.6 sets between Japanese and a Western character or numeral applies only to a
+* character rotated 90 degrees in vertical writing mode or mixed into horizontal writing mode —
+* 3.2.6 states that scope explicitly. A character set upright keeps its own rule, 3.2.4, which
+* reads it as a full-width monospace glyph classed with kanji and set solid against its neighbours,
+* the same as a tate-chu-yoko run's 3.2.5.
 */
 function classify({ value, presentation }) {
 	if (presentation === "tate-chu-yoko") return "cl-30";
+	if (presentation === "upright") return "cl-19";
 	if (OPENING.has(value)) return "cl-01";
 	if (CLOSING.has(value)) return "cl-02";
 	if (HYPHENS.has(value)) return "cl-03";
@@ -377,10 +385,6 @@ const REDUCTION_STAGE = {
 * {@link REDUCTION_STAGE}: the lower the number, the earlier the paragraph optimizer takes it. A
 * line is either reduced or expanded, never both, so the two scales never meet.
 *
-* Stage 4 spreads whatever a、b and c could not absorb across every character gap that is not
-* unbreakable, and is deliberately not implemented: it would justify every line that currently
-* falls short, which reads as prose combed out to the margin rather than a novel.
-*
 * Nothing here takes priority 0. Expanding is always visible, and priority 0 means an adjustment
 * the optimizer is charged nothing for.
 */
@@ -396,7 +400,11 @@ const EXPANSION_STAGE = {
 	/**
 	* Stage 3: everywhere else 表6 admits, from solid up to a quarter em.
 	*/
-	solid: 3
+	solid: 3,
+	/**
+	* Stage 4: the unbounded remainder, spread equally across every colored or gray cell of 表6.
+	*/
+	final: 4
 };
 /**
 * 無印 in 表1 with no colour in 表6: the pair is set solid and line adjustment leaves it alone.
@@ -457,7 +465,9 @@ const FIXED_QUARTER = {
 };
 /**
 * `1/4-1/8` in 表3 with `1/4-1/2` in 表6: the Japanese-to-western quarter em, reducible to an eighth
-* and expandable to a half.
+* and expandable to a half. 3.2.6 sets this only against a Western character rotated 90 degrees or
+* mixed into horizontal text (cl-27) and a numeral or unit symbol (cl-24, cl-25); an upright
+* Western character classifies as cl-19 instead and never reaches this constant.
 */
 const MIXED_TEXT_QUARTER = {
 	kind: "glue",
@@ -568,9 +578,10 @@ const EDGE_WORD_SPACE = {
 	naturalWidthEm: 0
 };
 /**
-* The classes that take a quarter em against a numeral, unit symbol or western character (3.2.6).
-* Dividing punctuation is on the list in that direction only, because the space before a `？` or `！`
-* is solid (3.1.6).
+* The classes that take a quarter em against a numeral, unit symbol or western character rotated 90
+* degrees or mixed into horizontal text (3.2.6) — an upright western character classifies as cl-19
+* and is covered by the general kanji rows and columns instead. Dividing punctuation is on the list
+* in that direction only, because the space before a `？` or `！` is solid (3.1.6).
 */
 const JAPANESE_BEFORE_WESTERN = [
 	"cl-04",
@@ -635,6 +646,125 @@ const EXPANDABLE_AFTER = [
 	"cl-30"
 ];
 /**
+* The gray, blue and pink cells of 表6: all pairs that join the fourth and final expansion stage.
+* The finite capacities above cover the blue and pink cells at stages three and two; once those
+* stages are exhausted, JLReq 3.8.4 d adds the remainder equally across every cell named here.
+*
+* A cl-08/cl-08 cell is blue only when the two characters are different kinds of mark (注4). This
+* profile cannot distinguish the two halves of one 2倍ダッシュ from different marks, so it keeps the
+* pair joined, as it already does for the finite third stage.
+*/
+const FINAL_EXPANSION_BASIC_AFTER = /* @__PURE__ */ new Set([
+	"cl-01",
+	"cl-08",
+	"cl-12",
+	"cl-13",
+	"cl-14",
+	"cl-15",
+	"cl-16",
+	"cl-19",
+	"cl-24",
+	"cl-25",
+	"cl-26",
+	"cl-27",
+	"cl-30"
+]);
+const FINAL_EXPANSION_WIDE_AFTER = /* @__PURE__ */ new Set([
+	...FINAL_EXPANSION_BASIC_AFTER,
+	"cl-09",
+	"cl-10",
+	"cl-11"
+]);
+const FINAL_EXPANSION_AFTER = new Map([
+	...[
+		"cl-02",
+		"cl-03",
+		"cl-04",
+		"cl-05",
+		"cl-06",
+		"cl-07",
+		"cl-14"
+	].map((left) => [left, FINAL_EXPANSION_BASIC_AFTER]),
+	...[
+		"cl-09",
+		"cl-10",
+		"cl-11",
+		"cl-13",
+		"cl-15",
+		"cl-16",
+		"cl-19",
+		"cl-30"
+	].map((left) => [left, FINAL_EXPANSION_WIDE_AFTER]),
+	["cl-08", new Set([...FINAL_EXPANSION_WIDE_AFTER].filter((characterClass) => characterClass !== "cl-08"))],
+	["cl-12", /* @__PURE__ */ new Set([
+		"cl-08",
+		"cl-09",
+		"cl-10",
+		"cl-11",
+		"cl-12",
+		"cl-13",
+		"cl-15",
+		"cl-16",
+		"cl-19",
+		"cl-25",
+		"cl-26",
+		"cl-27",
+		"cl-30"
+	])],
+	["cl-24", /* @__PURE__ */ new Set([
+		"cl-01",
+		"cl-08",
+		"cl-09",
+		"cl-10",
+		"cl-11",
+		"cl-12",
+		"cl-14",
+		"cl-15",
+		"cl-16",
+		"cl-19",
+		"cl-25",
+		"cl-26",
+		"cl-30"
+	])],
+	["cl-25", /* @__PURE__ */ new Set([
+		"cl-01",
+		"cl-08",
+		"cl-09",
+		"cl-10",
+		"cl-11",
+		"cl-12",
+		"cl-13",
+		"cl-14",
+		"cl-15",
+		"cl-16",
+		"cl-19",
+		"cl-24",
+		"cl-26",
+		"cl-30"
+	])],
+	["cl-26", new Set(japaneseCharacterClasses.filter((characterClass) => characterClass !== "cl-02"))],
+	["cl-27", /* @__PURE__ */ new Set([
+		"cl-01",
+		"cl-08",
+		"cl-09",
+		"cl-10",
+		"cl-11",
+		"cl-12",
+		"cl-13",
+		"cl-14",
+		"cl-15",
+		"cl-16",
+		"cl-19",
+		"cl-26",
+		"cl-30"
+	])]
+]);
+function canExpandAtFinalStage(left, right) {
+	if (left === "cl-14" || left === "cl-26" || left === "cl-27" || right === "cl-14" || right === "cl-26" || right === "cl-27") return false;
+	if (FINAL_EXPANSION_AFTER.get(left)?.has(right) !== true) return false;
+	return pairSpacing(left, right).naturalWidthEm === 0;
+}
+/**
 * The classes JLReq 3.1.2 sets on a half em rather than a full one.
 */
 const HALF_EM_CLASSES = /* @__PURE__ */ new Set([
@@ -922,6 +1052,8 @@ const defaultJapaneseTypesettingProfile = {
 		},
 		absorbsPrecedingEm: .25
 	} : null,
+	finalStretchPriority: EXPANSION_STAGE.final,
+	canExpandAtFinalStage,
 	breakPenalty,
 	/**
 	* Hanging punctuation (ぶら下げ組, JLReq 3.8.2) lets a full stop or comma sit outside the text area
@@ -951,6 +1083,15 @@ function skipSourceGaps(atoms, start) {
 function previousVisible(atoms, end) {
 	for (let index = end - 1; index >= 0; index -= 1) if (atoms[index]?.sourceGap === false) return index;
 }
+/**
+* Whether a shorter line ending somewhere inside `(contentStart, end)` was ever an option — checked
+* as a plain short-circuiting scan rather than building the boundary list first, since this runs
+* once per over-long candidate the optimizer considers.
+*/
+function hasEarlierBoundary(boundaryAllowed, contentStart, end) {
+	for (let boundary = contentStart + 1; boundary < end; boundary += 1) if (boundaryAllowed(boundary - 1, boundary)) return true;
+	return false;
+}
 function opportunities(atoms, classes, start, end, profile, lineHead) {
 	const result = [];
 	const firstClass = classes[start];
@@ -961,6 +1102,7 @@ function opportunities(atoms, classes, start, end, profile, lineHead) {
 			boundary: start
 		},
 		spacing: startSpacing,
+		finalStretch: false,
 		absorbsPrecedingEm: 0
 	});
 	for (let index = start; index < end; index += 1) {
@@ -973,6 +1115,7 @@ function opportunities(atoms, classes, start, end, profile, lineHead) {
 				index
 			},
 			spacing,
+			finalStretch: false,
 			absorbsPrecedingEm: 0
 		});
 	}
@@ -988,6 +1131,7 @@ function opportunities(atoms, classes, start, end, profile, lineHead) {
 				boundary: right
 			},
 			spacing: profile.pairSpacing(leftClass, rightClass),
+			finalStretch: profile.canExpandAtFinalStage(leftClass, rightClass),
 			absorbsPrecedingEm: 0
 		});
 	}
@@ -999,6 +1143,7 @@ function opportunities(atoms, classes, start, end, profile, lineHead) {
 			boundary: end
 		},
 		spacing: endSpacing.spacing,
+		finalStretch: false,
 		absorbsPrecedingEm: endSpacing.absorbsPrecedingEm
 	});
 	return result;
@@ -1072,17 +1217,20 @@ function adjustmentUnits(values, adjustment) {
 * Within a stage the amount is therefore split in proportion to what each space can give, rather
 * than taken out of the earliest space until it runs dry. Across stages the order stays a
 * waterfall: a later stage is reached only once every stage before it is spent out. The composer
-* sets one character size, so a share of the stage's capacity is a share by character size.
+* sets one character size, so a share of the stage's capacity is a share by character size. JLReq
+* 3.8.4's final stage has no upper bound: after the finite stages are full, the unresolved
+* remainder is added equally to every pair the profile admits, including the earlier-stage pairs.
 *
 * An all-or-nothing unit larger than what is still needed is skipped rather than partly spent, and
 * never revisited: `remaining` only falls, so a unit that did not fit at its own stage cannot fit
 * at a later one. One forward pass is therefore exact and no search over subsets is needed.
 */
-function resolveSpacings(values, units, adjustment, amountEm) {
+function resolveSpacings(values, units, adjustment, amountEm, finalStretchPriority) {
 	const usedBySlot = /* @__PURE__ */ new Map();
 	let remaining = amountEm;
 	let priorityCost = 0;
 	let freeEm = 0;
+	let finalStretchPerSlotEm = 0;
 	const spend = (unit, fraction) => {
 		for (const { slot, amountEm: partEm } of unit.parts) {
 			const key = slotKey(slot);
@@ -1109,6 +1257,20 @@ function resolveSpacings(values, units, adjustment, amountEm) {
 		const fraction = Math.min(remaining, stageCapacityEm) / stageCapacityEm;
 		for (const unit of stage) if (unit.granularity === "continuous") spend(unit, fraction);
 	}
+	if (adjustment === "stretch" && remaining > EPSILON) {
+		let finalSlotCount = 0;
+		for (const { finalStretch } of values) if (finalStretch) finalSlotCount += 1;
+		if (finalSlotCount > 0) {
+			finalStretchPerSlotEm = remaining / finalSlotCount;
+			for (const { slot, finalStretch } of values) {
+				if (!finalStretch) continue;
+				const key = slotKey(slot);
+				usedBySlot.set(key, (usedBySlot.get(key) ?? 0) + finalStretchPerSlotEm);
+			}
+			priorityCost += remaining * finalStretchPriority;
+			remaining = 0;
+		}
+	}
 	return {
 		spacings: splitBySlot(values, (slot, spacing) => {
 			const used = usedBySlot.get(slotKey(slot)) ?? 0;
@@ -1116,6 +1278,7 @@ function resolveSpacings(values, units, adjustment, amountEm) {
 		}),
 		priorityCost,
 		freeEm,
+		finalStretchPerSlotEm,
 		unabsorbedEm: Math.max(0, remaining)
 	};
 }
@@ -1159,11 +1322,11 @@ function hangingSpacings(values, end) {
 		characterSpacings
 	};
 }
-function candidate(atoms, classes, start, end, lineLengthEm, profile) {
+function candidate(atoms, classes, boxPrefixEm, 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, start === 0 ? "paragraph-start" : "turned-over");
-	const naturalSizeEm = atoms.slice(contentStart, end).reduce((total, atom) => total + atom.boxAdvanceEm, 0) + pairValues.reduce((total, value) => total + value.spacing.naturalWidthEm, 0);
+	const naturalSizeEm = (boxPrefixEm[end] ?? 0) - (boxPrefixEm[contentStart] ?? 0) + pairValues.reduce((total, value) => total + value.spacing.naturalWidthEm, 0);
 	const terminal = skipSourceGaps(atoms, end) === atoms.length;
 	const overflow = naturalSizeEm - lineLengthEm;
 	const underflow = lineLengthEm - naturalSizeEm;
@@ -1174,6 +1337,7 @@ function candidate(atoms, classes, start, end, lineLengthEm, profile) {
 	const lastClass = lastVisible === void 0 ? void 0 : classes[lastVisible];
 	const lastAdvance = lastVisible === void 0 ? 0 : atoms[lastVisible]?.boxAdvanceEm ?? 0;
 	const trailingSpacing = pairValues.find(({ slot }) => slot.kind === "gap" && slot.boundary === end)?.spacing.naturalWidthEm ?? 0;
+	const hasFinalStretch = pairValues.some(({ finalStretch }) => finalStretch);
 	if (terminal && overflow <= EPSILON) return {
 		start,
 		contentStart,
@@ -1198,7 +1362,7 @@ function candidate(atoms, classes, start, end, lineLengthEm, profile) {
 		deformationRatio: 0,
 		priorityCost: 0
 	};
-	const shrunk = overflow > 0 && overflow <= capacity + EPSILON ? resolveSpacings(pairValues, units, "shrink", overflow) : null;
+	const shrunk = overflow > 0 && overflow <= capacity + EPSILON ? resolveSpacings(pairValues, units, "shrink", overflow, profile.finalStretchPriority) : null;
 	if (shrunk !== null && shrunk.unabsorbedEm <= EPSILON) {
 		const chargeableCapacity = capacity - freeShrinkCapacity;
 		const chargeableShrink = Math.max(0, overflow - shrunk.freeEm);
@@ -1227,7 +1391,7 @@ function candidate(atoms, classes, start, end, lineLengthEm, profile) {
 		deformationRatio: overflow / Math.max(lastAdvance, EPSILON),
 		priorityCost: 0
 	};
-	const stretched = !terminal && underflow > EPSILON && underflow <= capacity + EPSILON ? resolveSpacings(pairValues, units, "stretch", underflow) : null;
+	const stretched = !terminal && underflow > EPSILON && (underflow <= capacity + EPSILON || hasFinalStretch) ? resolveSpacings(pairValues, units, "stretch", underflow, profile.finalStretchPriority) : null;
 	if (stretched !== null && stretched.unabsorbedEm <= EPSILON) return {
 		start,
 		contentStart,
@@ -1237,7 +1401,7 @@ function candidate(atoms, classes, start, end, lineLengthEm, profile) {
 		inlineSizeEm: lineLengthEm,
 		break: { kind: "stretched" },
 		hangingIndex: null,
-		deformationRatio: capacity === 0 ? 0 : underflow / capacity,
+		deformationRatio: stretched.finalStretchPerSlotEm > 0 ? 1 + stretched.finalStretchPerSlotEm : capacity === 0 ? 0 : underflow / capacity,
 		priorityCost: stretched.priorityCost
 	};
 	return {
@@ -1287,6 +1451,22 @@ function addScore(left, right) {
 		left[6] + right[6]
 	];
 }
+/**
+* The line-end offsets a state's path took, earliest first. Rebuilt on demand by walking `previous`
+* rather than carried on every `State`: every candidate line attempted would otherwise pay for a
+* copy of its whole path, when `isBetter` only ever reads it on the exact-score tie this comparison
+* breaks — for `boundaryAllowed` predicates permissive enough to fully saturate the optimizer's
+* search window, ties are rare enough that this deferred cost is negligible.
+*/
+function breaksOf(state, states) {
+	const result = [];
+	let cursor = state;
+	while (cursor?.line !== null && cursor?.line !== void 0) {
+		result.push(cursor.line.end);
+		cursor = cursor.previous === null ? void 0 : states.get(cursor.previous.index)?.get(cursor.previous.fitness);
+	}
+	return result.reverse();
+}
 function compareBreaks(left, right) {
 	const length = Math.min(left.length, right.length);
 	for (let index = 0; index < length; index += 1) {
@@ -1295,17 +1475,19 @@ function compareBreaks(left, right) {
 	}
 	return left.length - right.length;
 }
-function isBetter(candidateState, current) {
+function isBetter(candidateState, current, states) {
 	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;
+	return compareBreaks(breaksOf(candidateState, states), breaksOf(current, states)) < 0;
 }
 function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
 	if (atoms.length === 0) return [];
 	const classes = atoms.map(({ characterClass }) => characterClass);
+	const boxPrefixEm = Array.from({ length: atoms.length + 1 }).fill(0);
+	for (let index = 0; index < atoms.length; index += 1) boxPrefixEm[index + 1] = (boxPrefixEm[index] ?? 0) + (atoms[index]?.boxAdvanceEm ?? 0);
 	const states = /* @__PURE__ */ new Map([[0, /* @__PURE__ */ new Map([[0, {
 		score: [
 			0,
@@ -1318,8 +1500,7 @@ function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
 		],
 		fitness: 0,
 		previous: null,
-		line: null,
-		breaks: []
+		line: null
 	}]])]]);
 	for (let start = 0; start < atoms.length; start += 1) {
 		const activeStates = states.get(start);
@@ -1327,7 +1508,7 @@ function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
 		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);
+			for (const state of activeStates.values()) if (isBetter(state, terminalStates.get(state.fitness), states)) terminalStates.set(state.fitness, state);
 			states.set(atoms.length, terminalStates);
 			continue;
 		}
@@ -1336,8 +1517,8 @@ function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
 			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))) {
+			const line = candidate(atoms, classes, boxPrefixEm, start, end, lineLengthEm, profile);
+			if (line.break.kind === "forced" && line.inlineSizeEm > lineLengthEm + EPSILON && hasEarlierBoundary(boundaryAllowed, contentStart, end)) {
 				if (line.inlineSizeEm > lineLengthEm * 2 && end > contentStart + 1) break;
 				continue;
 			}
@@ -1349,18 +1530,17 @@ function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
 					index: start,
 					fitness: state.fitness
 				},
-				line,
-				breaks: [...state.breaks, end]
+				line
 			};
 			const statesAtEnd = states.get(end) ?? /* @__PURE__ */ new Map();
-			if (isBetter(nextState, statesAtEnd.get(nextState.fitness))) {
+			if (isBetter(nextState, statesAtEnd.get(nextState.fitness), states)) {
 				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);
+	const terminal = [...states.get(atoms.length)?.values() ?? []].reduce((best, state) => isBetter(state, best, states) ? state : best, void 0);
 	if (terminal === void 0) return [];
 	const lines = [];
 	let cursor = terminal;

package/dist/{novel-composer-BCt9g172.d.mts → novel-composer-DhycV9B3.d.mts}

@@ -1,4 +1,4 @@
-import { a as ManuscriptResult, i as ParsedManuscript, t as ComposedManuscript } from "./composed-manuscript-QgIdae8p.mjs";
+import { a as ManuscriptResult, i as ParsedManuscript, t as ComposedManuscript } from "./composed-manuscript-C0f3mxKs.mjs";
 import * as v from "valibot";
 //#region src/result/rejection.d.ts
 declare const RejectionSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{

package/dist/plugin.d.mts

@@ -1,3 +1,3 @@
-import { a as ManuscriptResult, i as ParsedManuscript, n as ValidationIssue, r as NamespacedId } from "./composed-manuscript-QgIdae8p.mjs";
-import { a as InlineMeasureRequest, c as logicalInlineMeasurer, f as ManuscriptComposer, m as Rejection, n as createNovelComposer, o as InlineMeasurement, p as ManuscriptParser, s as InlineMeasurer } from "./novel-composer-BCt9g172.mjs";
+import { a as ManuscriptResult, i as ParsedManuscript, n as ValidationIssue, r as NamespacedId } from "./composed-manuscript-C0f3mxKs.mjs";
+import { a as InlineMeasureRequest, c as logicalInlineMeasurer, f as ManuscriptComposer, m as Rejection, n as createNovelComposer, o as InlineMeasurement, p as ManuscriptParser, s as InlineMeasurer } from "./novel-composer-DhycV9B3.mjs";
 export { type InlineMeasureRequest, type InlineMeasurement, type InlineMeasurer, type ManuscriptComposer, type ManuscriptParser, ManuscriptResult, NamespacedId, ParsedManuscript, type Rejection, ValidationIssue, createNovelComposer, logicalInlineMeasurer };

package/dist/plugin.mjs

@@ -1,3 +1,3 @@
 import { c as ManuscriptResult, d as NamespacedId, s as ValidationIssue } from "./question-or-exclamation-spacing-B5o23ZLf.mjs";
-import { a as logicalInlineMeasurer, p as ParsedManuscript, t as createNovelComposer } from "./novel-composer-CtovfhET.mjs";
+import { a as logicalInlineMeasurer, p as ParsedManuscript, t as createNovelComposer } from "./novel-composer-DRgsEA2s.mjs";
 export { ManuscriptResult, NamespacedId, ParsedManuscript, ValidationIssue, createNovelComposer, logicalInlineMeasurer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sushichan044/kg-core",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Framework-independent parsing, composition, and proofreading for Japanese manuscripts",
   "keywords": [
     "japanese",