@vyaz/core 0.0.1 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vyaz/core",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -9,16 +9,20 @@
     "access": "public"
   },
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target bun"
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
+    "test": "bun test"
   },
   "dependencies": {
     "@chenglou/pretext": "^0.0.8",
     "@clean-jsdoc-theme/typedoc": "^5.0.6",
-    "@napi-rs/canvas": "^1.0.1",
     "fontkit": "^2.0.4",
+    "get-system-fonts": "^2.0.2",
     "js-yaml": "^5.0.0",
     "typedoc": "^0.28.19"
   },
+  "optionalDependencies": {
+    "@napi-rs/canvas": "^1.0.2"
+  },
   "devDependencies": {
     "@types/node": "^26.0.0"
   }

package/src/compile/DocumentCompiler.ts

@@ -9,12 +9,40 @@
  */
 
 import type { Paragraph, TextRun } from '../types/Document.js';
+import { DEFAULT_TEXT_STYLE } from '../types/Document.js';
+
+// ── Font Weight normalization (matching react-pdf convention) ───────────
+
+export const FONT_WEIGHTS: Record<string, number> = {
+  thin: 100,
+  hairline: 100,
+  ultralight: 200,
+  extralight: 200,
+  light: 300,
+  normal: 400,
+  medium: 500,
+  semibold: 600,
+  demibold: 600,
+  bold: 700,
+  ultrabold: 800,
+  extrabold: 800,
+  heavy: 900,
+  black: 900,
+};
+
+/** Normalize fontWeight to a numeric value (400 by default). */
+export function normalizeFontWeight(weight: number | string | undefined): number {
+  if (weight == null) return FONT_WEIGHTS.normal;
+  if (typeof weight === 'number') return weight;
+  return FONT_WEIGHTS[weight.toLowerCase()] ?? FONT_WEIGHTS.normal;
+}
 
 /** Font token for pretext: "${style}_${weight}_${fontSize}_${family}" */
 export function makeFontToken(run: TextRun, effectiveFontSize: number): string {
-  const fontStyle = run.fontStyle || 'normal';
-  const fontWeight = run.fontWeight || 400;
-  return `${fontStyle} ${fontWeight} ${effectiveFontSize}px ${run.fontFamily}`;
+  const fontStyle = run.fontStyle || DEFAULT_TEXT_STYLE.fontStyle || 'normal';
+  const fontWeight = normalizeFontWeight(run.fontWeight ?? DEFAULT_TEXT_STYLE.fontWeight);
+  const fontFamily = run.fontFamily || DEFAULT_TEXT_STYLE.fontFamily || 'Arial';
+  return `${fontStyle} ${fontWeight} ${effectiveFontSize}px ${fontFamily}`;
 }
 
 /** Compilation context (passed to pretext) */
@@ -47,20 +75,34 @@ export function compileParagraph(paragraph: Paragraph): PreparedRichInlineItem[]
     const run = paragraph.children[i];
 
     // Compute effective fontSize and baselineOffset
-    let effectiveFontSize = run.fontSize;
+    const baseFontSize = run.fontSize ?? DEFAULT_TEXT_STYLE.fontSize ?? 12;
+    let effectiveFontSize = baseFontSize;
     let baselineOffset = 0;
 
     if (run.script === 'super') {
-      effectiveFontSize = run.fontSize * SUPER_SUB_SCALE;
-      baselineOffset = run.fontSize * SUPER_OFFSET_RATIO;
+      effectiveFontSize = baseFontSize * SUPER_SUB_SCALE;
+      baselineOffset = baseFontSize * SUPER_OFFSET_RATIO;
     } else if (run.script === 'sub') {
-      effectiveFontSize = run.fontSize * SUPER_SUB_SCALE;
-      baselineOffset = run.fontSize * SUB_OFFSET_RATIO;
+      effectiveFontSize = baseFontSize * SUPER_SUB_SCALE;
+      baselineOffset = baseFontSize * SUB_OFFSET_RATIO;
     }
 
     // Inline-box: text → \uFFFC
     const text = run.type === 'inline-box' ? '\uFFFC' : run.text;
 
+    // Normalize fontWeight to numeric value
+    const resolvedFontWeight = normalizeFontWeight(run.fontWeight ?? DEFAULT_TEXT_STYLE.fontWeight);
+
+    // Fill missing style fields from DEFAULT_TEXT_STYLE
+    const resolvedStyle: TextRun = {
+      ...DEFAULT_TEXT_STYLE,
+      ...run,
+      fontSize: effectiveFontSize,
+      fontWeight: resolvedFontWeight,
+      text: run.text,
+      type: run.type,
+    } as TextRun;
+
     const item: PreparedRichInlineItem = {
       text,
       font: makeFontToken(run, effectiveFontSize),
@@ -69,7 +111,7 @@ export function compileParagraph(paragraph: Paragraph): PreparedRichInlineItem[]
         originalRunIndex: i,
         baselineOffset,
         effectiveFontSize,
-        style: { ...run, fontSize: effectiveFontSize },
+        style: resolvedStyle,
         inlineWidget: run.inlineWidget,
       },
     };

package/src/index.ts

@@ -37,9 +37,9 @@ export {
 // ── Output types (Physical Box Model) ───────────────────────────────────
 export type {
   ParagraphLayoutResult,
-  LineBox,
-  FragmentBox,
-  FragmentFontMetrics,
+  Line,
+  Span,
+  SpanFontMetrics,
   SemanticParagraph,
   SemanticLine,
   SemanticFragment,
@@ -54,8 +54,8 @@ export type {
 
 // ── Layout Engine ───────────────────────────────────────────────────────
 export { ParagraphLayoutEngine, paragraphLayoutEngine } from './layout/ParagraphLayoutEngine.js';
-export { positionLineBoxes } from './layout/PositioningEngine.js';
-export { assertLineBoxInvariants, lineBoxToYAML } from './layout/LineBoxValidator.js';
+export { positionLines } from './layout/PositioningEngine.js';
+export { assertLineInvariants, linesToYAML } from './layout/LineBoxValidator.js';
 export type { InvariantError } from './layout/LineBoxValidator.js';
 
 // ── TextFrame Layout Engine ──────────────────────────────────────────────
@@ -73,4 +73,8 @@ export type { PreparedRichInlineItem } from './compile/DocumentCompiler.js';
 // ── Font metrics ────────────────────────────────────────────────────────
 export { FontMetricsProvider, fontMetricsProvider } from './measure/FontMetricsProvider.js';
 
+// ── System font registry ────────────────────────────────────────────────
+export { SystemFontRegistry, systemFontRegistry } from './measure/SystemFontRegistry.js';
 
+// ── Errors ──────────────────────────────────────────────────────────────
+export { FontNotFoundError } from './measure/FontNotFoundError.js';

package/src/layout/LineBoxValidator.ts

@@ -8,7 +8,7 @@
  */
 
 import { dump } from 'js-yaml';
-import type { LineBox, FragmentBox, SemanticParagraph } from '../types/LayoutTypes.js';
+import type { Line, Span, SemanticParagraph } from '../types/LayoutTypes.js';
 
 const EPSILON = 0.5; // subpixel tolerance
 
@@ -21,11 +21,11 @@ export interface InvariantError {
 }
 
 /**
- * Check all 5 invariants for a LineBox array.
+ * Check all 5 invariants for a Line array.
  * Throws on first violation.
  */
-export function assertLineBoxInvariants(
-  lines: LineBox[],
+export function assertLineInvariants(
+  lines: Line[],
   originalText: string,
   maxWidth: number,
 ): void {
@@ -78,19 +78,19 @@ export function assertLineBoxInvariants(
       });
     }
 
-    // 5. BASELINE_EQ: all fragments in a line have the same baseline
-    if (line.fragments.length > 1) {
+    // 5. BASELINE_EQ: all spans in a line have the same baseline
+    if (line.spans.length > 1) {
       const firstBaseline = line.baseline;
-      for (let j = 0; j < line.fragments.length; j++) {
-        const frag = line.fragments[j];
-        const fragBaseline = frag.fontMetrics.ascent;
-        if (Math.abs(fragBaseline - firstBaseline) > EPSILON) {
+      for (let j = 0; j < line.spans.length; j++) {
+        const span = line.spans[j];
+        const spanBaseline = span.fontMetrics.ascent;
+        if (Math.abs(spanBaseline - firstBaseline) > EPSILON) {
           // NOTE: baseline may differ for super/sub — that's normal
           // So we only check that baseline is set
-          if (fragBaseline <= 0) {
+          if (spanBaseline <= 0) {
             errors.push({
               invariant: 'BASELINE_EQ',
-              message: `Line ${i}, fragment ${j}: baseline=${fragBaseline} is invalid`,
+              message: `Line ${i}, span ${j}: baseline=${spanBaseline} is invalid`,
             });
           }
         }
@@ -117,21 +117,21 @@ export function assertLineBoxInvariants(
 
 // ── YAML serialization ─────────────────────────────────────────────────
 
-/** Fragment style label for snapshot */
-function fragmentStyleLabel(frag: FragmentBox): 'bold' | 'italic' | 'normal' {
-  if (frag.style.fontStyle === 'italic') return 'italic';
-  const w = frag.style.fontWeight;
+/** Span style label for snapshot */
+function spanStyleLabel(span: Span): 'bold' | 'italic' | 'normal' {
+  if (span.style.fontStyle === 'italic') return 'italic';
+  const w = span.style.fontWeight;
   if (w === 'bold' || w === 700) return 'bold';
   return 'normal';
 }
 
 /**
- * Convert LineBox[] to YAML string for snapshots.
+ * Convert Line[] to YAML string for snapshots.
  * Only semantic data: text, x, width, style.
  * No glyphAdvances, fontMetrics (noise), inlineWidget.
  */
-export function lineBoxToYAML(
-  lines: LineBox[],
+export function linesToYAML(
+  lines: Line[],
   paragraphWidth: number,
   paragraphHeight: number,
 ): string {
@@ -143,11 +143,11 @@ export function lineBoxToYAML(
       width: Math.round(line.width * 100) / 100,
       height: Math.round(line.height * 100) / 100,
       baseline: Math.round(line.baseline * 100) / 100,
-      fragments: line.fragments.map(frag => ({
-        text: frag.text,
-        x: Math.round(frag.x * 100) / 100,
-        width: Math.round(frag.width * 100) / 100,
-        ...(fragmentStyleLabel(frag) !== 'normal' ? { style: fragmentStyleLabel(frag) } : {}),
+      fragments: line.spans.map(span => ({
+        text: span.text,
+        x: Math.round(span.x * 100) / 100,
+        width: Math.round(span.width * 100) / 100,
+        ...(spanStyleLabel(span) !== 'normal' ? { style: spanStyleLabel(span) } : {}),
       })),
     })),
   };
@@ -158,4 +158,5 @@ export function lineBoxToYAML(
     noRefs: true,
     sortKeys: false,
   });
-}
+}
+

package/src/layout/ParagraphLayoutEngine.ts

@@ -6,8 +6,8 @@
  *   → compile (DocumentCompiler)
  *   → prepareRichInline (pretext)
  *   → walkRichInlineLineRanges + materializeRichInlineLineRange (pretext)
- *   → positionLineBoxes (PositioningEngine)
- *   → assertLineBoxInvariants (LineBoxValidator)
+ *   → positionLines (PositioningEngine)
+ *   → assertLineInvariants (LineInvariants)
  *
  * Supports autofit via AutoFitEngine.findScale.
  * Caches PreparedRichInline per paragraph key (Parley LayoutContext pattern).
@@ -23,8 +23,8 @@ import type { ParagraphLayoutResult } from '../types/LayoutTypes.js';
 import { compileParagraph, getParagraphText } from '../compile/DocumentCompiler.js';
 import type { PreparedRichInlineItem } from '../compile/DocumentCompiler.js';
 import { fontMetricsProvider } from '../measure/FontMetricsProvider.js';
-import { positionLineBoxes } from './PositioningEngine.js';
-import { assertLineBoxInvariants } from './LineBoxValidator.js';
+import { positionLines } from './PositioningEngine.js';
+import { assertLineInvariants } from './LineBoxValidator.js';
 
 // @ts-ignore
 import { prepareRichInline, materializeRichInlineLineRange, walkRichInlineLineRanges, type PreparedRichInline } from '@chenglou/pretext/rich-inline';
@@ -52,7 +52,7 @@ export class ParagraphLayoutEngine {
    * @param paragraph — input paragraph
    * @param maxWidth — available container width (px)
    * @param fontProvider — optional metrics provider (default: fontMetricsProvider)
-   * @returns ParagraphLayoutResult with LineBox[]
+   * @returns ParagraphLayoutResult with Line[]
    */
   layout(
     paragraph: Paragraph,
@@ -89,7 +89,7 @@ export class ParagraphLayoutEngine {
 
     // Phase 4: Position
     const renderMode = provider.getMode();
-    const { lines, contentWidth } = positionLineBoxes(
+    const { lines, contentWidth } = positionLines(
       materializedLines,
       items,
       (item) => {
@@ -111,7 +111,7 @@ export class ParagraphLayoutEngine {
     );
 
     // Phase 5: Validate
-    assertLineBoxInvariants(lines, getParagraphText(paragraph), maxWidth);
+    assertLineInvariants(lines, getParagraphText(paragraph), maxWidth);
 
     // Phase 6: Compute height
     const totalHeight = lines.length > 0
@@ -129,8 +129,8 @@ export class ParagraphLayoutEngine {
   /**
    * Layout with per-glyph advance widths (for SVG glyph mode).
    *
-   * After basic layout, fills FragmentBox.glyphAdvances
-   * via fontkit for each text fragment.
+   * After basic layout, fills Span.glyphAdvances
+   * via fontkit for each text span.
    *
    * @param paragraph — input paragraph
    * @param maxWidth — available container width (px)
@@ -145,14 +145,14 @@ export class ParagraphLayoutEngine {
     const result = this.layout(paragraph, maxWidth, yOffset);
 
     for (const line of result.lines) {
-      for (const frag of line.fragments) {
-        if (frag.type === 'text' && frag.text.length > 0) {
-          frag.glyphAdvances = this.computeGlyphAdvances(
-            frag.text,
-            frag.style.fontFamily,
-            frag.fontMetrics.fontSize,
-            String(frag.style.fontWeight || 400),
-            frag.style.fontStyle || 'normal',
+      for (const span of line.spans) {
+        if (span.type === 'text' && span.text.length > 0) {
+          span.glyphAdvances = this.computeGlyphAdvances(
+            span.text,
+            span.style.fontFamily,
+            span.fontMetrics.fontSize,
+            String(span.style.fontWeight || 400),
+            span.style.fontStyle || 'normal',
           );
         }
       }

package/src/layout/PositioningEngine.ts

@@ -1,24 +1,24 @@
 /**
  * PositioningEngine.ts — pure X/Y positioning math.
  *
- * Takes pretext output (lines with fragments) + font metrics +
- * paragraph style → returns LineBox[] with absolute coordinates.
+ * Takes pretext output (spans with fragments) + font metrics +
+ * paragraph style → returns Line[] with absolute coordinates.
  *
  * X: alignment (left/center/right/justify) + indent
  * Y: baseline + lineHeight + spaceBefore/After
- * Justify: fragmented approach (each space → separate FragmentBox)
+ * Justify: fragmented approach (each space → separate Span)
  *
  * Specs:
  * - CSS Text Module Level 3/4 (browser mode)
  * - ISO/IEC 29500 (Office Open XML / DrawingML, office mode)
  * - Parley alignment.rs (conceptually close, but here justify is simpler:
- *   slack is divided equally among stretchable space-fragments,
+ *   slack is divided equally among stretchable space-spans,
  *   without mutating ClusterData.advance)
  */
 
 import type { ParagraphStyle } from '../types/Document.js';
 import type { FontMetrics } from '../types/FontTypes.js';
-import type { LineBox, FragmentBox, FragmentFontMetrics } from '../types/LayoutTypes.js';
+import type { Line, Span, SpanFontMetrics } from '../types/LayoutTypes.js';
 import type { PreparedRichInlineItem } from '../compile/DocumentCompiler.js';
 
 // ── Helper types for pretext ───────────────────────────────────────────
@@ -41,18 +41,18 @@ interface PretextLine {
 // ── PositioningEngine ─────────────────────────────────────────────────
 
 /**
- * Build LineBox[] from pretext lines with alignment and metrics.
+ * Build Line[] from pretext lines with alignment and metrics.
  *
  * @param pretextLines — pretext result (materializeRichInlineLineRange)
  * @param items — original PreparedRichInlineItem[] (for metadata)
- * @param fontMetricsFn — function to get font metrics for a fragment
+ * @param fontMetricsFn — function to get font metrics for a span
  * @param style — paragraph style
  * @param maxWidth — available container width
  * @param startY — initial Y position
  * @param mode — metric mode ('browser' | 'office'), affects line height calculation
- * @returns { lines: LineBox[], contentWidth: number }
+ * @returns { lines: Line[], contentWidth: number }
  */
-export function positionLineBoxes(
+export function positionLines(
   pretextLines: PretextLine[],
   items: PreparedRichInlineItem[],
   fontMetricsFn: (item: PreparedRichInlineItem) => FontMetrics,
@@ -61,8 +61,8 @@ export function positionLineBoxes(
   startY: number = 0,
   mode: 'browser' | 'office' = 'browser',
   paragraphId?: string,
-): { lines: LineBox[]; contentWidth: number } {
-  const lines: LineBox[] = [];
+): { lines: Line[]; contentWidth: number } {
+  const lines: Line[] = [];
   let currentY = startY + style.spaceBefore;
   let charIndex = 0;
   let isFirstLine = true;
@@ -71,11 +71,11 @@ export function positionLineBoxes(
   for (let lineIdx = 0; lineIdx < pretextLines.length; lineIdx++) {
     const ptLine = pretextLines[lineIdx];
 
-    // ── Build FragmentBox[] ────────────────────────────
+    // ── Build Span[] ────────────────────────────
     let maxAscent = 0;
     let maxDescent = 0;
     let maxLineHeightBase = 0; // max(ascent + descent) — for Office mode
-    const fragments: FragmentBox[] = [];
+    const spans: Span[] = [];
 
     for (const frag of ptLine.fragments) {
       const item = items[frag.itemIndex];
@@ -92,7 +92,7 @@ export function positionLineBoxes(
 
       // pretext: gapBefore — inter-word space BEFORE the word
       // occupiedWidth = gapBefore + textWidth
-      // Split into two FragmentBox: space + word
+      // Split into two Span: space + word
       const gapWidth = frag.gapBefore || 0;
       const textWidth = frag.occupiedWidth;
 
@@ -100,10 +100,11 @@ export function positionLineBoxes(
         ascent: metrics.ascent,
         descent: metrics.descent,
         fontSize: item.metadata.effectiveFontSize,
+        baselineOffset: item.metadata.baselineOffset || undefined,
       };
 
       if (gapWidth > 0) {
-        fragments.push({
+        spans.push({
           x: 0,
           width: gapWidth,
           text: ' ',
@@ -116,7 +117,7 @@ export function positionLineBoxes(
         });
       }
 
-      // Split leading/trailing spaces from frag.text into separate space fragments
+      // Split leading/trailing spaces from frag.text into separate space spans
       // This is needed for SVG rendering to avoid xml:space="preserve" dependency
       const text = frag.text;
       const leadingMatch = text.match(/^(\s+)/);
@@ -142,9 +143,9 @@ export function positionLineBoxes(
         return totalChars > 0 ? (charCount / totalChars) * textWidth : 0;
       };
 
-      // Leading space fragment
+      // Leading space span
       if (leadingSpaceChars > 0) {
-        fragments.push({
+        spans.push({
           x: 0,
           width: computePartialWidth(leadingSpaceChars),
           text: text.slice(0, leadingSpaceChars),
@@ -157,7 +158,7 @@ export function positionLineBoxes(
         });
       }
 
-      // Text fragment (trimmed)
+      // Text span (trimmed)
       if (remainingText.length > 0) {
         const textWidth = computePartialWidth(remainingText.length);
         // Compute per-glyph advances by distributing textWidth equally across glyphs.
@@ -170,7 +171,7 @@ export function positionLineBoxes(
             glyphAdvances.push(perGlyph);
           }
         }
-        fragments.push({
+        spans.push({
           x: 0,
           width: textWidth,
           text: remainingText,
@@ -184,10 +185,10 @@ export function positionLineBoxes(
         });
       }
 
-      // Trailing space fragment
+      // Trailing space span
       if (trailingSpaceChars > 0) {
         const trailingStart = leadingSpaceChars + remainingText.length;
-        fragments.push({
+        spans.push({
           x: 0,
           width: computePartialWidth(trailingSpaceChars),
           text: text.slice(trailingStart, trailingStart + trailingSpaceChars),
@@ -201,34 +202,43 @@ export function positionLineBoxes(
       }
     }
 
-    // ── Mark trailing whitespace fragments ───────────────────
+    // ── Inline-box width correction ─────────────────────────
+    // When a span has an inlineWidget, override its width
+    // to match the widget width (the \uFFFC advance is not included).
+    for (const s of spans) {
+      if (s.inlineWidget) {
+        s.width = s.inlineWidget.width;
+      }
+    }
+
+    // ── Mark trailing whitespace spans ───────────────────
     // CSS Text §4.1.3: end-of-line spaces have zero measure for line-advance calculations.
     // Parley: LineItemData.has_trailing_whitespace → trailing whitespace is excluded from advance.
     //
     // Find the last space(s) at the end of the line and mark them trailing.
-    let trailingStartIndex = fragments.length;
-    for (let i = fragments.length - 1; i >= 0; i--) {
-      if (fragments[i].type === 'space') {
+    let trailingStartIndex = spans.length;
+    for (let i = spans.length - 1; i >= 0; i--) {
+      if (spans[i].type === 'space') {
         trailingStartIndex = i;
       } else {
         break;
       }
     }
 
-    const trailingWidth = fragments
+    const trailingWidth = spans
       .slice(trailingStartIndex)
       .reduce((sum, f) => sum + f.width, 0);
 
-    for (let i = trailingStartIndex; i < fragments.length; i++) {
-      fragments[i].trailing = true;
+    for (let i = trailingStartIndex; i < spans.length; i++) {
+      spans[i].trailing = true;
     }
 
     // ── Compute effective line width (excluding trailing whitespace) ─
-    // Use sum of actual fragment widths instead of ptLine.width, because
+    // Use sum of actual span widths instead of ptLine.width, because
     // ptLine.width may not include gapBefore spaces that were split into
-    // separate FragmentBox (e.g. "AA" + " A" → [AA][ ][A]).
-    const totalFragWidth = fragments.reduce((sum, f) => sum + f.width, 0);
-    const effectiveLineWidth = totalFragWidth - trailingWidth;
+    // separate Span (e.g. "AA" + " A" → [AA][ ][A]).
+    const totalSpanWidth = spans.reduce((sum, f) => sum + f.width, 0);
+    const effectiveLineWidth = totalSpanWidth - trailingWidth;
 
     // ── X positioning ───────────────────────────────
     const indent = isFirstLine
@@ -246,7 +256,7 @@ export function positionLineBoxes(
     } else if (style.alignment === 'right') {
       xOffset = indent + slack;
     } else if (style.alignment === 'justify') {
-      // Justify: distribute slack evenly among whitespace fragments
+      // Justify: distribute slack evenly among whitespace spans
       // (excluding trailing whitespace).
       //
       // CSS Text Module Level 3 §4.1.3: trailing spaces do not participate in justify.
@@ -259,7 +269,7 @@ export function positionLineBoxes(
       const isLastLine = lineIdx === pretextLines.length - 1;
 
       // Count only "stretchable" spaces: type === 'space' and !trailing
-      const stretchableSpaces = fragments.filter(
+      const stretchableSpaces = spans.filter(
         (f) => f.type === 'space' && !f.trailing,
       );
       const spaceCount = stretchableSpaces.length;
@@ -278,7 +288,7 @@ export function positionLineBoxes(
 
     // Assign X positions
     let runX = xOffset;
-    for (const frag of fragments) {
+    for (const frag of spans) {
       frag.x = Math.round(runX * 100) / 100;
       runX += frag.width;
     }
@@ -297,7 +307,7 @@ export function positionLineBoxes(
     //   Line height strictly = ascent + descent (OS/2.usWinAscent + usWinDescent).
     //   Baseline = Top + ascent without any half-leading additions.
     //   See pixel-perfect-text-layout.md §1 and ECMA-376.
-    const maxFontSize = fragments.reduce((max, f) => Math.max(max, f.fontMetrics.fontSize), 0);
+    const maxFontSize = spans.reduce((max, f) => Math.max(max, f.fontMetrics.fontSize), 0);
 
     const ascentRounded = Math.round(maxAscent);
     const descentRounded = Math.round(maxDescent);
@@ -345,24 +355,24 @@ export function positionLineBoxes(
 
     // Count characters in line (for INDEX_CONSIST)
     let lineCharCount = 0;
-    for (const frag of fragments) {
+    for (const frag of spans) {
       lineCharCount += frag.text.length;
     }
     const endIdx = startIdx + lineCharCount;
     charIndex = endIdx;
 
-    // ── Mark break type on the last fragment ─────────────
+    // ── Mark break type on the last span ─────────────
     // 'soft' — line wrap due to width constraint
     // 'hard' — explicit break (\n)
     // 'none'/undefined — not a line end (no break)
-    if (fragments.length > 0) {
-      const lastFrag = fragments[fragments.length - 1];
-      const lastFragItem = items[lastFrag.itemIndex];
+    if (spans.length > 0) {
+      const lastSpan = spans[spans.length - 1];
+      const lastSpanItem = items[lastSpan.itemIndex];
       // If last character is \n, it's a hard break
-      if (lastFragItem && lastFrag.text.endsWith('\n')) {
-        lastFrag.breakType = 'hard';
+      if (lastSpanItem && lastSpan.text.endsWith('\n')) {
+        lastSpan.breakType = 'hard';
       } else if (lineIdx < pretextLines.length - 1) {
-        lastFrag.breakType = 'soft';
+        lastSpan.breakType = 'soft';
       }
     }
 
@@ -377,7 +387,7 @@ export function positionLineBoxes(
       startIndex: startIdx,
       endIndex: endIdx,
       alignment: style.alignment,
-      fragments,
+      spans,
     });
 
     currentY += lineBoxHeight;