diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2ad60eb..af61ff5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.13.0
+
+- **Character-range highlight boxes:** `RenderHyperBox.getBoxesForCharRange(charStart, charEnd)` returns the rects of a character range, for drawing your own highlights (search hits, annotations, read-aloud). Offsets are local to each `RenderHyperBox`, so in virtualized / `auto` mode (>10k chars) they restart at 0 per chunk. Also new: `RenderHyperBox.debugLineFragments()` for the laid-out fragment geometry. By [@DrkXo](https://github.com/DrkXo) ([#26](https://github.com/brewkits/hyper_render/pull/26)).
+- **`text-overflow: ellipsis` fixes** (in `hyper_render_core`): the `…` glyph is no longer counted as a hidden source character, a selection highlight no longer covers it, and an empty line where nothing fits before the ellipsis now shows `…`.
+- **Line-breaking fixes** (in `hyper_render_core`, rendering changes): wrapped lines no longer overflow the box (every full CJK line overflowed by a fraction of a glyph), RTL paragraphs wrap properly, `word-break` / `overflow-wrap` set on a block reach its text (`break-all` had no effect), an over-long word breaks after as many characters as fit instead of after its first letter, a word that doesn't fit beside a float moves below it, lines no longer start one space in (after `<br>` or an indented tag), and centered / right-aligned lines ignore trailing spaces.
+- **Line-breaking performance on massive unspaced text blocks** ([#28](https://github.com/brewkits/hyper_render/issues/28), [#29](https://github.com/brewkits/hyper_render/pull/29)): single-pass native multi-line layout via ICU `computeLineMetrics()` when lines are uniform and free of floats, eliminating layout freezes on long unspaced text blocks. Bounded candidate prefix search in the fallback line breaker prevents quadratic `O(N^2)` text shaping overhead. New debug hooks `HyperRenderDebugHooks.onTextPainterLayout` / `onLineLayoutTextPainter` for layout call profiling. By [@DrkXo](https://github.com/DrkXo).
+- **Requires `hyper_render_core` `^1.13.0`.**
+
 ## 1.12.0
 
 - **Dark surfaces: links, `<h6>`, `<code>` / `<pre>` and `<mark>` now use dark-surface colors** ([#23](https://github.com/brewkits/hyper_render/issues/23)). In 1.11.0 only the default text color followed a dark theme; these built-in colors were still tuned for light surfaces and measured 4.1:1 (links), 3.9:1 (`<h6>`) and **2.5:1** (`<pre><code>`) on `#121212`. They now keep at least 4.5:1, and the inline `<code>` / `<mark>` chips become dark chips instead of bright blocks. The palette is chosen from the *effective text color*: light text means a dark surface, so a dark `Theme` with `textColor: Colors.black87` (a white pane) keeps the light-surface palette, and a light `Theme` with a light `textColor` gets the dark one. Light-surface output is unchanged. Author CSS and inline styles still win. `<blockquote>`, `<kbd>` and table headers keep their light backgrounds (their text is kept readable by the 1.11.0 contrast guard). **Requires `hyper_render_core` `^1.12.0`** (`StyleResolver.darkSurface`). `hyper_render_epub` 0.1.3 needs no update: it goes through `HyperViewer`, so it picks this up automatically.
diff --git a/README.md b/README.md
index 8cb42d3..b040a5f 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ Already using `flutter_html`? You don't need to rewrite your widget tree or lear
 ```dart
 // 1. In your pubspec.yaml:
 // dependencies:
-//   hyper_render: ^1.12.0
+//   hyper_render: ^1.13.0
 
 // 2. In your Dart file — replace this single line:
 // ❌ import 'package:flutter_html/flutter_html.dart';
@@ -68,7 +68,7 @@ Html(
 
 ```yaml
 dependencies:
-  hyper_render: ^1.12.0
+  hyper_render: ^1.13.0
 ```
 
 ```dart
diff --git a/ROADMAP.md b/ROADMAP.md
index 11c1458..03e78e7 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -14,6 +14,7 @@ This document outlines the architectural roadmap for **HyperRender** to become t
 | **v1.10.0** | Shipped 2026-10-02 | **DevTools v2 & Stylesheet CSS Correctness** | Timeline / Selection / live CSS-variable / snapshot DevTools tabs; stylesheet `var()`, `url()`, `calc()` and `:root` fixed. |
 | **v1.11.0** | Shipped 2026-10-04 | **Dark Mode & Root Colors** | Dark-`Theme` text default, `HyperViewer(textColor:)` / `EpubReader(textColor:)`, `body`/`html` `color`, `:root` fix, contrast guard (#20). |
 | **v1.12.0** | Shipped 2026-10-04 | **Dark-Surface Element Colors** | Links, `<h6>`, `<code>` / `<pre>`, `<mark>` keep >= 4.5:1 on dark surfaces (#23). |
+| **v1.13.0** | Shipped 2026-10-08 | **Character-Range Highlight Geometry** | `getBoxesForCharRange` / `debugLineFragments` for app-drawn highlights; ellipsis character-count fix (#26). |
 | **Next** | Unscheduled | **Native Vector Diagramming & Headless Export** | Pure Canvas/Vector Mermaid.js & GraphViz (Zero-WebView), Headless Image & PDF byte stream generator. |
 | **v2.0.0** | Q1 2027 | **Interactive Editorial & Magazine Typography** | Medium-style Text Annotation/Highlighting layer, Multi-column layout (`column-count`), Z-Index Stacking Context, Vertical Text (`writing-mode: vertical-rl`). |
 
diff --git a/doc/CSS_PROPERTIES_MATRIX.md b/doc/CSS_PROPERTIES_MATRIX.md
index 0a65ac3..a82d480 100644
--- a/doc/CSS_PROPERTIES_MATRIX.md
+++ b/doc/CSS_PROPERTIES_MATRIX.md
@@ -1,7 +1,7 @@
 # CSS Properties Support Matrix
 
-Last Updated: October 4, 2026
-Version: 1.12.0
+Last Updated: October 8, 2026
+Version: 1.13.0
 
 This document lists CSS property support in HyperRender.
 
diff --git a/doc/MIGRATION_GUIDE.md b/doc/MIGRATION_GUIDE.md
index 2d8f97a..d841735 100644
--- a/doc/MIGRATION_GUIDE.md
+++ b/doc/MIGRATION_GUIDE.md
@@ -1,6 +1,17 @@
 # Migration Guide
 
-> **Current version: v1.12.0**
+> **Current version: v1.13.0**
+
+## Upgrading to v1.13.0
+
+No breaking changes. New: `RenderHyperBox.getBoxesForCharRange` and `debugLineFragments` ([#26](https://github.com/brewkits/hyper_render/pull/26)). Two small `text-overflow: ellipsis` changes: selecting truncated text no longer highlights the `…` glyph, and a line where not even one character fits before the ellipsis now shows `…` instead of staying empty.
+
+**Line breaking changed in a few cases**, so wrapped text can land on different lines than in 1.12.0: lines no longer overflow the box by part of a glyph (most visible in CJK), RTL paragraphs wrap properly, `word-break` / `overflow-wrap` on a block now apply to its text, an over-long word breaks after as many characters as fit, a word that doesn't fit beside a float moves below it, lines no longer start one space in after `<br>` or an indented tag, and centered / right-aligned lines no longer count trailing spaces. If you have pixel tests of wrapped text, expect to regenerate them.
+
+```yaml
+dependencies:
+  hyper_render: ^1.13.0
+```
 
 ## Upgrading to v1.12.0
 
@@ -216,6 +227,9 @@ These APIs are stable and will remain backward-compatible in v2.0:
 
 ## Version History
 
+### v1.13.0 (October 2026)
+- `RenderHyperBox.getBoxesForCharRange` / `debugLineFragments`, ellipsis character-count fix ([#26](https://github.com/brewkits/hyper_render/pull/26))
+
 ### v1.12.0 (October 2026)
 - Dark-surface colors for links, `<h6>`, `<code>` / `<pre>` and `<mark>` ([#23](https://github.com/brewkits/hyper_render/issues/23))
 
diff --git a/doc/ROADMAP.md b/doc/ROADMAP.md
index a03ac6e..54db51c 100644
--- a/doc/ROADMAP.md
+++ b/doc/ROADMAP.md
@@ -1,7 +1,7 @@
 # HyperRender — Product Roadmap
 
-**Last Updated**: 2026-10-03
-**Current Stable**: v1.12.0
+**Last Updated**: 2026-10-08
+**Current Stable**: v1.13.0
 **Repository**: [github.com/brewkits/hyper_render](https://github.com/brewkits/hyper_render)
 
 This document tracks the long-term direction of the HyperRender ecosystem.
@@ -33,6 +33,7 @@ For detailed CSS property tracking, see [`CSS_PROPERTIES_MATRIX.md`](CSS_PROPERT
   `hyper_render_markdown`, `hyper_render_highlight`, `hyper_render_clipboard`
 - **`hyper_render_devtools` v1.0.0** — UDT Tree inspector, Computed Style panel, Layout fragment/line data, demo mode (no live app required); published to pub.dev
 - **`hyper_render_devtools` v1.8.0** (2026-10-02) — the panel actually connects now (#17), plus Timeline, Selection debugger, live CSS-variable editing and JSON snapshot export. Requires `hyper_render_core` 1.10.0.
+- **Character-range highlight geometry** (1.13.0) — `RenderHyperBox.getBoxesForCharRange` returns line-aligned rects for any character range (search hits, annotations), and `debugLineFragments()` exposes laid-out fragment geometry; `text-overflow: ellipsis` no longer counts the `…` glyph as a source character (#26, by @DrkXo).
 - **Dark-surface element colors** (1.12.0) — links, `<h6>`, `<code>` / `<pre>` and `<mark>` switch to dark-surface variants (>= 4.5:1) when the effective text color is light (#23).
 - **Dark mode & root colors** (1.11.0) — unstyled text follows a dark `Theme`, `HyperViewer(textColor:)` / `EpubReader(textColor:)`, `body`/`html` `color` honoured, `:root` matches only the document root, readable text on light UA surfaces (#20). Block plugins on custom tags (`<info-box>`) now render (#22).
 - **Stylesheet CSS correctness** (core 1.10.0) — `var()`, `url()`, `calc()` in `<style>` / `customCss` now resolve (inline-only before), custom properties cascade before substitution, `:root` matches only the document root, `var()` expansion capped.
diff --git a/packages/hyper_render_core/CHANGELOG.md b/packages/hyper_render_core/CHANGELOG.md
index edfdd66..174b5c6 100644
--- a/packages/hyper_render_core/CHANGELOG.md
+++ b/packages/hyper_render_core/CHANGELOG.md
@@ -1,5 +1,26 @@
 # Changelog — hyper_render_core
 
+## 1.13.0
+
+- **`RenderHyperBox.getBoxesForCharRange(charStart, charEnd)`** — bounding boxes for a character range, for app-drawn highlights (search hits, annotations, read-aloud). Offsets are the selection/IME character space, local to this `RenderHyperBox`: in virtualized / `auto` mode (>10k chars) each chunk has its own box and offsets restart at 0. Glyph x-bounds come from `TextPainter` (so they follow `textScaler` and justified spacing); y-bounds span the full line. Rects of adjacent words on a line merge, except across an inline atom such as an image. Spaces inside `white-space: pre` / `pre-wrap` / `break-spaces` are kept. By [@DrkXo](https://github.com/DrkXo) ([#26](https://github.com/brewkits/hyper_render/pull/26), follow-up to [#17](https://github.com/brewkits/hyper_render/pull/17)).
+- **`RenderHyperBox.debugLineFragments()`** — the fragments as laid out on lines, with the position actually painted, `charStart` / `charEnd`, line index / top / height, ruby text and `ellipsisVisibleLength`. `debugFragments()` reports pre-layout fragments and misses wrapped and truncated pieces.
+- **`text-overflow: ellipsis`: the truncated fragment now records how many source characters it shows.** The `ellipsisVisibleLength` was only set on the original fragment, which never reaches a line, so the `…` glyph counted as a source character.
+- **Behavior changes:** a selection highlight on truncated text no longer covers the `…` glyph, matching `getSelectedText`; and when not even one character fits before the ellipsis on an empty line, the line now shows `…` instead of nothing.
+
+- **Line-breaking fixes** (rendering changes, found while reviewing [#29](https://github.com/brewkits/hyper_render/pull/29)):
+  - **Lines no longer run past the box.** A wrap point was taken from the nearest caret rather than the last one that fits, so a line could overflow by up to half a glyph; every full CJK line did.
+  - **RTL paragraphs wrap.** The line breaker read an RTL paragraph from its logical end, putting most of it on line one and then one glyph per line.
+  - **`word-break` and `overflow-wrap` are inherited**, as in CSS. Set on a `<p>`, they never reached its text, so `word-break: break-all` had no effect.
+  - **A word wider than the line breaks after as many characters as fit** (like Flutter's `Text`), instead of after its first letter, which left a column of one-letter lines.
+  - **A word that doesn't fit beside a float moves below it** instead of being split after its first letter.
+  - **Spaces at the start and end of a line collapse**, as in CSS. A line after `<p>` + newline, after `<br>`, or after an indented `<dt>` started one space in, and trailing spaces counted toward the width that `text-align: center/right` positions.
+- **Line-breaking performance on massive unspaced text blocks** ([#28](https://github.com/brewkits/hyper_render/issues/28), [#29](https://github.com/brewkits/hyper_render/pull/29)):
+  - Single-pass native multi-line layout fast path via ICU `computeLineMetrics()` when lines are uniform and free of floats, eliminating UI freezes on long unspaced text.
+  - Bounded candidate prefix search in the fallback line breaker loop to prevent quadratic `O(N^2)` HarfBuzz text shaping overhead.
+  - Robust loop termination on zero or negative line widths and trailing whitespace margin parity.
+  - **Behavior change from the native layout:** CJK text now fills the line after a space between two sentences or runs (as a browser does), where it used to start the next run on a new line, and a first-in-document block with `text-overflow: ellipsis` now truncates instead of wrapping (it emitted no block-start fragment, so the ellipsis state was never entered).
+- **`HyperRenderDebugHooks.onTextPainterLayout` / `onLineLayoutTextPainter`** — hook callbacks for counting text shaping and line layout operations in tests and DevTools. By [@DrkXo](https://github.com/DrkXo) ([#29](https://github.com/brewkits/hyper_render/pull/29)).
+
 ## 1.12.0
 
 - **`StyleResolver.darkSurface`** (default `false`) — switches the built-in link, `<h6>`, `<code>`, `<pre><code>` and `<mark>` colors to dark-surface variants with at least 4.5:1 contrast on `#121212` ([#23](https://github.com/brewkits/hyper_render/issues/23)). `HyperViewer` sets it whenever its effective default text color is light. Author CSS still wins; an `<a>` without `href` is untouched.
diff --git a/packages/hyper_render_core/README.md b/packages/hyper_render_core/README.md
index b239b1b..772fa91 100644
--- a/packages/hyper_render_core/README.md
+++ b/packages/hyper_render_core/README.md
@@ -10,7 +10,7 @@ Most apps should depend on [`hyper_render`](https://pub.dev/packages/hyper_rende
 
 ```yaml
 dependencies:
-  hyper_render_core: ^1.12.0
+  hyper_render_core: ^1.13.0
 ```
 
 ---
diff --git a/packages/hyper_render_core/lib/src/core/hyper_render_debug_hooks.dart b/packages/hyper_render_core/lib/src/core/hyper_render_debug_hooks.dart
index f8bd59b..f67a4a3 100644
--- a/packages/hyper_render_core/lib/src/core/hyper_render_debug_hooks.dart
+++ b/packages/hyper_render_core/lib/src/core/hyper_render_debug_hooks.dart
@@ -18,6 +18,8 @@ import '../model/node.dart';
 /// HyperRenderDebugHooks.onLayoutComplete   = (id, getFrags, getLines) { ... };
 /// HyperRenderDebugHooks.onFrameTiming      = (id, phase, micros) { ... };
 /// HyperRenderDebugHooks.onSelectionChanged = (id, start, end) { ... };
+/// HyperRenderDebugHooks.onTextPainterLayout = () { ... };
+/// HyperRenderDebugHooks.onLineLayoutTextPainter = () { ... };
 /// ```
 abstract final class HyperRenderDebugHooks {
   /// Called when a [RenderHyperBox] is attached to the pipeline.
@@ -63,6 +65,14 @@ abstract final class HyperRenderDebugHooks {
   /// selection was cleared.
   static void Function(String id, int? start, int? end)? onSelectionChanged;
 
+  /// Called in debug mode whenever a TextPainter performs layout in RenderHyperBox.
+  /// Used by tests and DevTools to count text shaping operations.
+  static void Function()? onTextPainterLayout;
+
+  /// Called in debug mode whenever a TextPainter performs layout during the line-breaking
+  /// pass in RenderHyperBox.
+  static void Function()? onLineLayoutTextPainter;
+
   /// CSS custom property overrides set from DevTools (`{'--name': value}`).
   ///
   /// In debug builds `HyperViewer` passes these to its
@@ -81,5 +91,7 @@ abstract final class HyperRenderDebugHooks {
           onRendererDetached != null ||
           onLayoutComplete != null ||
           onFrameTiming != null ||
-          onSelectionChanged != null);
+          onSelectionChanged != null ||
+          onTextPainterLayout != null ||
+          onLineLayoutTextPainter != null);
 }
diff --git a/packages/hyper_render_core/lib/src/core/render_hyper_box.dart b/packages/hyper_render_core/lib/src/core/render_hyper_box.dart
index c21e5d1..ce6a194 100644
--- a/packages/hyper_render_core/lib/src/core/render_hyper_box.dart
+++ b/packages/hyper_render_core/lib/src/core/render_hyper_box.dart
@@ -187,6 +187,10 @@ class RenderHyperBox extends RenderBox
   _LruCache<_TextPainterKey, TextPainter> get _textPainters =>
       _globalTextPainters;
 
+  /// Reusable TextPainter for measuring line-breaking candidate prefixes during
+  /// layout without polluting the global LRU cache.
+  TextPainter? _scratchCandidatePainter;
+
   /// Last collapsed margin (for margin collapsing between blocks)
   double _lastBlockMarginBottom = 0;
 
@@ -731,6 +735,8 @@ class RenderHyperBox extends RenderBox
     }
     _cancelBlockAnimationLoop();
     _disposeImages();
+    _scratchCandidatePainter?.dispose();
+    _scratchCandidatePainter = null;
     // Do NOT call detach() on cached semantic anchor nodes here.
     // Flutter's semantics teardown already detaches them during widget
     // unmounting — calling detach() again asserts inside SemanticsOwner
@@ -1088,6 +1094,7 @@ class RenderHyperBox extends RenderBox
 
         measurePainter.text = TextSpan(text: candidate, style: mergedStyle);
         measurePainter.layout();
+        if (kDebugMode) HyperRenderDebugHooks.onTextPainterLayout?.call();
         if (measurePainter.width > maxWidth) {
           maxWidth = measurePainter.width;
         }
diff --git a/packages/hyper_render_core/lib/src/core/render_hyper_box_layout.dart b/packages/hyper_render_core/lib/src/core/render_hyper_box_layout.dart
index 50e2a3b..e4b6151 100644
--- a/packages/hyper_render_core/lib/src/core/render_hyper_box_layout.dart
+++ b/packages/hyper_render_core/lib/src/core/render_hyper_box_layout.dart
@@ -224,7 +224,8 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
     if (effectiveMarginTop > 0 ||
         _fragments.isNotEmpty ||
         hasWidthConstraint ||
-        hasPadding) {
+        hasPadding ||
+        style.textOverflow == TextOverflow.ellipsis) {
       _fragments.add(_BlockStartFragment(
         sourceNode: node,
         style: style,
@@ -607,10 +608,13 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
           final text = fragment.text;
           if (text == null || text.isEmpty) {
             fragment.measuredSize = Size.zero;
+            fragment.baseline = 0;
             break;
           }
           final painter = _getTextPainter(text, fragment.style);
           fragment.measuredSize = Size(painter.width, painter.height);
+          fragment.baseline =
+              painter.computeDistanceToActualBaseline(TextBaseline.alphabetic);
           break;
 
         case FragmentType.ruby:
@@ -620,10 +624,13 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
         case FragmentType.lineBreak:
           final painter = _getTextPainter(' ', fragment.style);
           fragment.measuredSize = Size(0, painter.height);
+          fragment.baseline =
+              painter.computeDistanceToActualBaseline(TextBaseline.alphabetic);
           break;
 
         case FragmentType.atomic:
           // Already measured during tokenization
+          fragment.baseline = fragment.measuredSize?.height;
           break;
       }
 
@@ -659,6 +666,7 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
     fragment.measuredSize = Size(width, height);
     // Store ruby height for painting
     fragment.rubyHeight = rubyPainter.height;
+    fragment.baseline = height * 0.85;
   }
 
   /// The style a text/ruby fragment should actually be measured, painted and
@@ -673,6 +681,13 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
     );
   }
 
+  /// Whether [whiteSpace] preserves preformatted whitespace and line breaks.
+  bool _isPreformattedWhiteSpace(String? whiteSpace) {
+    return whiteSpace == 'pre' ||
+        whiteSpace == 'pre-wrap' ||
+        whiteSpace == 'break-spaces';
+  }
+
   TextPainter _getTextPainter(String text, ComputedStyle style) {
     // Per-fragment text direction (supports RTL via CSS direction: rtl)
     final fragmentDirection =
@@ -700,9 +715,8 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
     // FIXED: baseStyle is the foundation, computed style overrides it
     final mergedStyle = _baseStyle.merge(style.toTextStyle());
 
-    // Pre/pre-wrap fragments may contain multi-line text; allow unlimited lines
-    final isPreformatted =
-        style.whiteSpace == 'pre' || style.whiteSpace == 'pre-wrap';
+    // Pre/pre-wrap/break-spaces fragments may contain multi-line text; allow unlimited lines
+    final isPreformatted = _isPreformattedWhiteSpace(style.whiteSpace);
     final maxLines = isPreformatted ? null : 1;
 
     final painter = TextPainter(
@@ -728,6 +742,7 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
         applyHeightToLastDescent: true,
       ),
     )..layout();
+    if (kDebugMode) HyperRenderDebugHooks.onTextPainterLayout?.call();
 
     _textPainters.put(key, painter);
     return painter;
@@ -861,6 +876,32 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
         currentLineFragments.removeLast();
       }
 
+      // Collapsible spaces at the end of a line hang (CSS Text 3 §4.1.2):
+      // they must not count toward the width text-align centers or
+      // right-aligns, or the visible glyphs end up one space off.
+      if (currentLineFragments.isNotEmpty) {
+        final last = currentLineFragments.last;
+        final ws = last.style.whiteSpace;
+        if (last.type == FragmentType.text &&
+            last.text != null &&
+            last.text!.endsWith(' ') &&
+            ws != 'pre' &&
+            ws != 'pre-wrap' &&
+            ws != 'break-spaces') {
+          final trimmed = Fragment.text(
+            text: last.text!.trimRight(),
+            sourceNode: last.sourceNode,
+            style: last.style,
+            characterOffset: last.characterOffset,
+          )
+            ..globalOffset = last.globalOffset
+            ..offset = last.offset
+            ..ellipsisVisibleLength = last.ellipsisVisibleLength;
+          _measureFragment(trimmed);
+          currentLineFragments[currentLineFragments.length - 1] = trimmed;
+        }
+      }
+
       if (currentLineFragments.isEmpty) {
         // Line became empty after trimming whitespace - just flush floats.
         _leftFloats.addAll(_pendingLineLeftFloats);
@@ -1286,6 +1327,32 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
         return;
       }
 
+      // Collapsible spaces at the start of a line are removed (CSS Text 3
+      // §4.1.2), e.g. the indentation newline after `<p>` or after `<br>`.
+      // Without this every such line started one space in.
+      if (currentLineFragments.isEmpty &&
+          fragment.type == FragmentType.text &&
+          fragment.text != null) {
+        final ws = fragment.style.whiteSpace;
+        if (ws != 'pre' && ws != 'pre-wrap' && ws != 'break-spaces') {
+          final text = fragment.text!;
+          var lead = 0;
+          while (lead < text.length && text.codeUnitAt(lead) == 0x20) {
+            lead++;
+          }
+          if (lead == text.length) return;
+          if (lead > 0) {
+            fragment = Fragment.text(
+              text: text.substring(lead),
+              sourceNode: fragment.sourceNode,
+              style: fragment.style,
+              characterOffset: fragment.characterOffset + lead,
+            )..globalOffset = fragment.globalOffset + lead;
+            _measureFragment(fragment);
+          }
+        }
+      }
+
       final availableWidth = getAvailableWidth();
       // If floats were placed before any text on this line, currentX may still
       // be 0 (or behind the float boundary). Clamp it so remainingWidth is
@@ -1385,15 +1452,149 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
             }
           }
 
-          // Can't split to fit - start new line
+          // Can't split to fit - start new line, and process the fragment
+          // again there so the line-start rules (leading-space collapse)
+          // apply to it.
           if (currentLineFragments.isNotEmpty) {
             finishLine();
             currentX = leftInset;
+            pendingFragment = fragment;
+            return;
           }
 
           // Now check if fragment is wider than full line width
           final fullLineWidth = getAvailableWidth();
           if (fragment.width > fullLineWidth && fragment.text!.length > 1) {
+            // Fast path: When there are no active or pending floats and the fragment
+            // starts at the beginning of a line, available width is uniform across all
+            // lines. Layout the entire text in a single TextPainter pass via native
+            // ICU line-breaking, avoiding thousands of individual TextPainter.layout() calls.
+            final bool canUseNativeMultiLine = _leftFloats.isEmpty &&
+                _rightFloats.isEmpty &&
+                _pendingLineLeftFloats.isEmpty &&
+                _pendingLineRightFloats.isEmpty &&
+                currentLineFragments.isEmpty &&
+                fullLineWidth > 0 &&
+                ellipsisDepth == 0 &&
+                !fragment.style.isRtl &&
+                textDirection != ui.TextDirection.rtl &&
+                fragment.style.wordBreak != 'break-all' &&
+                fragment.style.textOverflow != TextOverflow.ellipsis &&
+                !_isPreformattedWhiteSpace(fragment.style.whiteSpace) &&
+                fragment.style.whiteSpace != 'nowrap';
+
+            if (canUseNativeMultiLine) {
+              final text = fragment.text!;
+              final totalLen = text.length;
+              final fragmentDirection =
+                  fragment.style.isRtl ? ui.TextDirection.rtl : textDirection;
+              final mergedStyle =
+                  _baseStyle.merge(fragment.style.toTextStyle());
+              final strutStyle = StrutStyle.fromTextStyle(mergedStyle,
+                  forceStrutHeight: false);
+
+              final multiPainter = _scratchCandidatePainter ??= TextPainter();
+              multiPainter
+                ..text = TextSpan(text: text, style: mergedStyle)
+                ..strutStyle = strutStyle
+                ..textDirection = fragmentDirection
+                ..textScaler = _textScaler
+                ..maxLines = null
+                ..textHeightBehavior = const TextHeightBehavior(
+                  applyHeightToFirstAscent: true,
+                  applyHeightToLastDescent: true,
+                )
+                ..layout(maxWidth: fullLineWidth);
+              if (kDebugMode) {
+                HyperRenderDebugHooks.onTextPainterLayout?.call();
+                HyperRenderDebugHooks.onLineLayoutTextPainter?.call();
+              }
+
+              final metrics = multiPainter.computeLineMetrics();
+              if (metrics.length > 1) {
+                int startOffset = 0;
+                for (int mIdx = 0; mIdx < metrics.length; mIdx++) {
+                  final lm = metrics[mIdx];
+                  int endOffset;
+                  if (mIdx == metrics.length - 1) {
+                    endOffset = totalLen;
+                  } else {
+                    final nextLm = metrics[mIdx + 1];
+                    final nextLineY = nextLm.baseline - nextLm.ascent / 2;
+                    final nextStartPos = multiPainter.getPositionForOffset(
+                      Offset(0, nextLineY),
+                    );
+                    endOffset = nextStartPos.offset;
+                    if (endOffset <= startOffset || endOffset > totalLen) {
+                      final lineY = lm.baseline - lm.ascent / 2;
+                      final pos = multiPainter.getPositionForOffset(
+                        Offset(fullLineWidth, lineY),
+                      );
+                      endOffset = pos.offset;
+                    }
+                  }
+
+                  if (endOffset <= startOffset && startOffset < totalLen) {
+                    endOffset = startOffset + 1;
+                  } else if (endOffset > totalLen) {
+                    endOffset = totalLen;
+                  }
+
+                  final lineText = text.substring(startOffset, endOffset);
+                  final lineFrag = Fragment.text(
+                    text: lineText,
+                    sourceNode: fragment.sourceNode,
+                    style: fragment.style,
+                    characterOffset: fragment.characterOffset + startOffset,
+                  )..globalOffset = fragment.globalOffset + startOffset;
+
+                  lineFrag.measuredSize = Size(lm.width, lm.height);
+                  lineFrag.baseline = lm.ascent;
+
+                  lineFrag.offset = Offset(currentX, currentY);
+                  currentLineFragments.add(lineFrag);
+                  _updateLineMetrics(lineFrag, lineHeight, maxBaseline, (h, b) {
+                    lineHeight = h;
+                    maxBaseline = b;
+                  });
+
+                  if (mIdx < metrics.length - 1) {
+                    finishLine();
+                    currentX = leftInset;
+                  } else {
+                    currentX += lineFrag.width;
+                  }
+                  startOffset = endOffset;
+                }
+                return;
+              }
+            }
+
+            // A float narrows this line and not even the first word fits
+            // beside it: move down past the float (as CSS line boxes do)
+            // instead of splitting the word after its first letter.
+            final contentWidth =
+                _maxWidth - leftPaddingStack.last - rightPaddingStack.last;
+            if (fullLineWidth < contentWidth - 0.5 &&
+                !_leadingUnitFits(fragment, fullLineWidth)) {
+              double? floatBottom;
+              for (final float in [..._leftFloats, ..._rightFloats]) {
+                if (currentY >= float.rect.top &&
+                    currentY < float.rect.bottom &&
+                    (floatBottom == null || float.rect.bottom < floatBottom)) {
+                  floatBottom = float.rect.bottom;
+                }
+              }
+              if (floatBottom != null) {
+                currentY = floatBottom;
+                _cachedAvailableWidth = null;
+                getAvailableWidth(); // refreshes leftInset for the new Y
+                currentX = leftInset;
+                pendingFragment = fragment;
+                return;
+              }
+            }
+
             // Fragment is wider than entire line - FORCE split
             final forceSplit = _forceSplitTextFragment(fragment, fullLineWidth);
             if (forceSplit != null) {
@@ -1420,6 +1621,14 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
         }
       }
 
+      // An oversized tail carries an estimated infinite width; measure it for
+      // real once it is placed. Do NOT also measure `measuredSize == null`
+      // fragments: a floated block's own text arrives unmeasured (known gap),
+      // and measuring it adds a phantom line height.
+      if (fragment.width.isInfinite) {
+        _measureFragment(fragment);
+      }
+
       fragment.offset = Offset(currentX, currentY);
       currentX += fragment.width;
       currentLineFragments.add(fragment);
@@ -1455,11 +1664,17 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
   /// Returns the distance from the top of [fragment] to its baseline.
   /// Single source of truth used by both [_updateLineMetrics] and [_positionFragments].
   double _fragmentBaseline(Fragment fragment) {
+    if (fragment.baseline != null) return fragment.baseline!;
     if (fragment.type == FragmentType.text && fragment.text != null) {
       final painter = _getTextPainter(fragment.text!, fragment.style);
-      return painter.computeDistanceToActualBaseline(TextBaseline.alphabetic);
+      final b =
+          painter.computeDistanceToActualBaseline(TextBaseline.alphabetic);
+      fragment.baseline = b;
+      return b;
     } else if (fragment.type == FragmentType.ruby) {
-      return fragment.height * 0.85;
+      final b = fragment.height * 0.85;
+      fragment.baseline = b;
+      return b;
     }
     return fragment.height; // atomic: bottom-align
   }
@@ -1501,15 +1716,142 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
     return isBeforeCjk || isAfterCjk;
   }
 
+  /// Rendered width of the first [length] code units of [painter]'s
+  /// single-line text, read from the caret position: measured from the left
+  /// edge for LTR and from the right edge for RTL. A caret lookup is cheap,
+  /// unlike summing `getBoxesForSelection(0, length)`, which costs O(length)
+  /// per call on a long paragraph.
+  double _prefixWidth(TextPainter painter, int length) {
+    if (length <= 0) return 0;
+    final caretX =
+        painter.getOffsetForCaret(TextPosition(offset: length), Rect.zero).dx;
+    return painter.textDirection == ui.TextDirection.rtl
+        ? painter.width - caretX
+        : caretX;
+  }
+
+  /// The longest prefix of [text] (laid out single-line in [painter]) whose
+  /// rendered width is at most [maxWidth].
+  ///
+  /// `getPositionForOffset(Offset(maxWidth, 0))` alone is not enough: it
+  /// returns the *nearest* caret, up to half a glyph past [maxWidth], and in
+  /// an RTL painter `x = maxWidth` from the left is the logical end of the
+  /// text, not its start. The probe is mirrored for RTL and the result is
+  /// corrected against measured prefix widths.
+  int _fitPrefixLength(TextPainter painter, String text, double maxWidth) {
+    const epsilon = 0.01;
+    final rtl = painter.textDirection == ui.TextDirection.rtl;
+    final probeX = rtl ? painter.width - maxWidth : maxWidth;
+    var fit = painter
+        .getPositionForOffset(Offset(probeX, 0))
+        .offset
+        .clamp(0, text.length);
+    while (fit > 0 && _prefixWidth(painter, fit) > maxWidth + epsilon) {
+      fit--;
+    }
+    while (fit < text.length &&
+        _prefixWidth(painter, fit + 1) <= maxWidth + epsilon) {
+      fit++;
+    }
+    return fit;
+  }
+
+  /// Whether the first unbreakable unit of [fragment] (its first word, or its
+  /// first character where any character boundary may break) fits in [width].
+  bool _leadingUnitFits(Fragment fragment, double width) {
+    final text = fragment.text!;
+    final painter = _getTextPainter(text, fragment.style);
+    final fit = _fitPrefixLength(painter, text, width);
+    if (fit <= 0) return false;
+    if (fragment.style.wordBreak == 'break-all' ||
+        KinsokuProcessor.containsCjk(text)) {
+      return true;
+    }
+    var wordStart = 0;
+    while (wordStart < text.length && text[wordStart] == ' ') {
+      wordStart++;
+    }
+    final space = text.indexOf(' ', wordStart);
+    return (space < 0 ? text.length : space) <= fit;
+  }
+
+  /// Checks if the leading run of [text] starting at [start] contains CJK characters.
+  bool _isLeadingCjk(String text, [int start = 0]) {
+    final limit = math.min(text.length, start + 32);
+    for (int i = start; i < limit; i++) {
+      if (KinsokuProcessor.isCjkCodeUnit(text.codeUnitAt(i))) return true;
+    }
+    return false;
+  }
+
+  /// Calculates the maximum number of characters that could possibly fit
+  /// within [maxWidth] given [style]. Bounded prefixes prevent O(N^2)
+  /// text shaping overhead on massive paragraphs (e.g. Gutenberg EPUBs).
+  int _safeCandidateCharLimit(double maxWidth, ComputedStyle style,
+      {bool isCjk = false}) {
+    final effectiveWidth = maxWidth > 0 ? maxWidth : 1.0;
+    final fontSize = style.fontSize > 0 ? style.fontSize : 16.0;
+    if (isCjk) {
+      // In CJK, fullwidth characters are 1.0 * fontSize wide. Bounding to
+      // (effectiveWidth / (fontSize * 0.75)).ceil() + 16 provides ample margin
+      // (~80-85 chars at 800px) while avoiding over-shaping 116+ chars per line.
+      return (effectiveWidth / (fontSize * 0.75)).ceil() + 16;
+    }
+    return (effectiveWidth / (fontSize * 0.25)).ceil() + 64;
+  }
+
+  /// Reusable TextPainter for layout candidate prefixes, avoiding allocating
+  /// transient objects or thrashing the global [_textPainters] cache.
+  TextPainter _getCandidatePainter(
+    String text,
+    ComputedStyle style, {
+    TextStyle? preMergedStyle,
+    StrutStyle? preStrutStyle,
+  }) {
+    final fragmentDirection =
+        style.isRtl ? ui.TextDirection.rtl : textDirection;
+    final mergedStyle = preMergedStyle ?? _baseStyle.merge(style.toTextStyle());
+    final strutStyle = preStrutStyle ??
+        StrutStyle.fromTextStyle(mergedStyle, forceStrutHeight: false);
+    final isPreformatted = _isPreformattedWhiteSpace(style.whiteSpace);
+    final maxLines = isPreformatted ? null : 1;
+
+    final painter = _scratchCandidatePainter ??= TextPainter();
+    painter
+      ..text = TextSpan(text: text, style: mergedStyle)
+      ..strutStyle = strutStyle
+      ..textDirection = fragmentDirection
+      ..textScaler = _textScaler
+      ..maxLines = maxLines
+      ..textHeightBehavior = const TextHeightBehavior(
+        applyHeightToFirstAscent: true,
+        applyHeightToLastDescent: true,
+      )
+      ..layout();
+    if (kDebugMode) {
+      HyperRenderDebugHooks.onTextPainterLayout?.call();
+      HyperRenderDebugHooks.onLineLayoutTextPainter?.call();
+    }
+    return painter;
+  }
+
   (Fragment, Fragment)? _splitTextFragment(Fragment fragment, double maxWidth) {
     final text = fragment.text!;
     if (text.isEmpty) return null;
 
-    final painter = _getTextPainter(text, fragment.style);
-    final position = painter.getPositionForOffset(Offset(maxWidth, 0));
-    int breakIndex = position.offset;
+    final isCjk = _isLeadingCjk(text);
+    final safeLimit =
+        _safeCandidateCharLimit(maxWidth, fragment.style, isCjk: isCjk);
+    final isCandidate = text.length > safeLimit;
+    final candidateText = isCandidate ? text.substring(0, safeLimit) : text;
+
+    final painter = isCandidate
+        ? _getCandidatePainter(candidateText, fragment.style)
+        : _getTextPainter(candidateText, fragment.style);
+    final fitIndex = _fitPrefixLength(painter, candidateText, maxWidth);
+    int breakIndex = fitIndex;
 
-    if (breakIndex > 0 && breakIndex < text.length) {
+    if (breakIndex > 0 && breakIndex < candidateText.length) {
       final style = fragment.style;
       final bool breakAll = style.wordBreak == 'break-all';
       final bool overflowWrap = style.overflowWrap == 'break-word' ||
@@ -1518,29 +1860,30 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
       if (breakAll) {
         // word-break: break-all -> Break at any character
       } else {
-        final beforeBreak = text.substring(0, breakIndex);
-        final lastSpace = beforeBreak.lastIndexOf(' ');
+        // Search from breakIndex inclusive: a space right after the fitting
+        // prefix means the whole word before it fits.
+        final lastSpace = candidateText.lastIndexOf(' ', breakIndex);
 
         if (lastSpace > 0) {
           // Found a space before break point - use it
           breakIndex = lastSpace + 1;
-        } else if (KinsokuProcessor.containsCjk(text)) {
+        } else if (KinsokuProcessor.containsCjk(candidateText)) {
           // Text contains CJK - check if break position is within CJK context
-          final isCjkBreak = _isBreakInCjkContext(text, breakIndex);
+          final isCjkBreak = _isBreakInCjkContext(candidateText, breakIndex);
 
           if (isCjkBreak) {
             // Break is in CJK region - apply Kinsoku rules
-            breakIndex = KinsokuProcessor.findBreakPoint(text, breakIndex);
-            if (breakIndex < 0) breakIndex = position.offset;
+            breakIndex =
+                KinsokuProcessor.findBreakPoint(candidateText, breakIndex);
+            if (breakIndex < 0) breakIndex = fitIndex;
           } else if (overflowWrap) {
             // Latin-region break with overflow-wrap -> Break at character
           } else {
             // Break is in Latin region of mixed text - treat as Latin
             // Look for next space AFTER break point to avoid breaking words
-            final afterBreak = text.substring(breakIndex);
-            final nextSpace = afterBreak.indexOf(' ');
+            final nextSpace = text.indexOf(' ', breakIndex);
 
-            if (nextSpace >= 0) {
+            if (nextSpace >= 0 || candidateText.length < text.length) {
               // Found space after - but this means moving more to next line
               return null;
             }
@@ -1552,10 +1895,9 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
         } else {
           // Pure Latin text without space before break point
           // Look for next space AFTER break point to avoid breaking words
-          final afterBreak = text.substring(breakIndex);
-          final nextSpace = afterBreak.indexOf(' ');
+          final nextSpace = text.indexOf(' ', breakIndex);
 
-          if (nextSpace >= 0) {
+          if (nextSpace >= 0 || candidateText.length < text.length) {
             // Found space after - but this means moving more to next line
             // Return null to signal "can't fit any complete word on this line"
             // The caller should start a new line and try again
@@ -1574,8 +1916,8 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
 
     // Ensure breakIndex aligns with grapheme cluster boundaries.
     // This prevents splitting emojis (even with ZWJ) or complex scripts.
-    if (breakIndex > 0 && breakIndex < text.length) {
-      final range = text.characters.iterator;
+    if (breakIndex > 0 && breakIndex < candidateText.length) {
+      final range = candidateText.characters.iterator;
       int currentOffset = 0;
       while (range.moveNext()) {
         int nextOffset = currentOffset + range.current.length;
@@ -1593,9 +1935,7 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
     // Only trim spaces for normal/nowrap/pre-line modes
     // For pre/pre-wrap/break-spaces, preserve all whitespace
     final whiteSpace = fragment.style.whiteSpace;
-    final shouldTrim = (whiteSpace != 'pre' &&
-        whiteSpace != 'pre-wrap' &&
-        whiteSpace != 'break-spaces');
+    final shouldTrim = !_isPreformattedWhiteSpace(whiteSpace);
 
     final firstPart = shouldTrim
         ? text.substring(0, breakIndex).trimRight()
@@ -1613,7 +1953,15 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
       style: fragment.style,
       characterOffset: fragment.characterOffset,
     )..globalOffset = fragment.globalOffset;
-    _measureFragment(firstFragment);
+
+    if (firstPart.length == breakIndex) {
+      final w = _prefixWidth(painter, breakIndex);
+      firstFragment.measuredSize = Size(w, painter.height);
+      firstFragment.baseline =
+          painter.computeDistanceToActualBaseline(TextBaseline.alphabetic);
+    } else {
+      _measureFragment(firstFragment);
+    }
 
     // characterOffset points to the START of secondPart in the document.
     // We use `breakIndex` (not `breakIndex + trimmedLeading`) so that trimmed
@@ -1625,7 +1973,19 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
       style: fragment.style,
       characterOffset: fragment.characterOffset + breakIndex,
     )..globalOffset = fragment.globalOffset + breakIndex;
-    _measureFragment(secondFragment);
+
+    // Optimization: If secondPart is far longer than could fit on ANY line in
+    // this container, skip expensive HarfBuzz layout and assign an estimated size.
+    // Container width _maxWidth is used rather than line maxWidth to avoid
+    // erroneously assuming the tail fits on the next full-width line.
+    final safeContainerLimit =
+        _safeCandidateCharLimit(_maxWidth, fragment.style, isCjk: isCjk);
+    if (secondPart.length > safeContainerLimit) {
+      secondFragment.measuredSize = Size(double.infinity, firstFragment.height);
+      secondFragment.baseline = firstFragment.baseline;
+    } else {
+      _measureFragment(secondFragment);
+    }
 
     return (firstFragment, secondFragment);
   }
@@ -1634,6 +1994,8 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
     if (fragment.type == FragmentType.text && fragment.text != null) {
       final painter = _getTextPainter(fragment.text!, fragment.style);
       fragment.measuredSize = Size(painter.width, painter.height);
+      fragment.baseline =
+          painter.computeDistanceToActualBaseline(TextBaseline.alphabetic);
     }
   }
 
@@ -1645,70 +2007,70 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
     final text = fragment.text!;
     if (text.length <= 1) return null;
 
-    // First, try to find a word boundary that fits
-    int breakIndex = -1;
-
-    // Find all space positions
-    final spaceIndices = <int>[];
-    for (int i = 0; i < text.length; i++) {
-      if (text[i] == ' ') {
-        spaceIndices.add(i);
-      }
-    }
-
-    // Use the full-text painter + getPositionForOffset to find where maxWidth
-    // cuts off the text, then snap back to the nearest space boundary.
-    // This is O(1) painter calls instead of O(words) substring painters.
-    if (spaceIndices.isNotEmpty) {
-      final painter = _getTextPainter(text, fragment.style);
-      final charPos = painter.getPositionForOffset(Offset(maxWidth, 0)).offset;
-      // Find the rightmost space that is at or before the cut position
-      int lo = 0, hi = spaceIndices.length - 1;
-      while (lo <= hi) {
-        final mid = (lo + hi) >> 1;
-        if (spaceIndices[mid] < charPos) {
-          breakIndex = spaceIndices[mid] + 1;
-          lo = mid + 1;
-        } else {
-          hi = mid - 1;
-        }
-      }
-    }
-
-    // If no word boundary fits, but overflow-wrap is enabled, or word-break: break-all
-    // then force split at character level
     final style = fragment.style;
     final bool breakAll = style.wordBreak == 'break-all';
     final bool overflowWrap =
         style.overflowWrap == 'break-word' || style.overflowWrap == 'anywhere';
 
+    final isCjk = _isLeadingCjk(text);
+    final safeLimit = _safeCandidateCharLimit(maxWidth, style, isCjk: isCjk);
+    final isCandidate = text.length > safeLimit;
+    final candidateText = isCandidate ? text.substring(0, safeLimit) : text;
+
+    // Longest prefix that really fits (not the nearest caret, which can run
+    // half a glyph past maxWidth, and mirrored for RTL painters).
+    final painter = isCandidate
+        ? _getCandidatePainter(candidateText, style)
+        : _getTextPainter(candidateText, style);
+    final fitIndex = _fitPrefixLength(painter, candidateText, maxWidth);
+
+    // First, try to find a word boundary that fits. word-break: break-all
+    // fills the line by character instead.
+    int breakIndex = -1;
+    if (!breakAll) {
+      // A space at fitIndex itself still counts: the word before it fits.
+      final space = fitIndex < candidateText.length
+          ? candidateText.lastIndexOf(' ', fitIndex)
+          : candidateText.lastIndexOf(' ');
+      if (space >= 0) breakIndex = space + 1;
+    }
+
+    // If no word boundary fits, but overflow-wrap is enabled, or word-break: break-all
+    // then force split at character level
     if (breakIndex == -1 &&
-        (breakAll || overflowWrap || KinsokuProcessor.containsCjk(text))) {
-      final painter = _getTextPainter(text, fragment.style);
-      final position = painter.getPositionForOffset(Offset(maxWidth, 0));
-      breakIndex = position.offset;
+        (breakAll ||
+            overflowWrap ||
+            KinsokuProcessor.containsCjk(candidateText))) {
+      breakIndex = fitIndex;
 
       // Adjust for CJK rules if applicable
-      if (KinsokuProcessor.containsCjk(text)) {
-        final kinsokuBreak = KinsokuProcessor.findBreakPoint(text, breakIndex);
+      if (KinsokuProcessor.containsCjk(candidateText)) {
+        final kinsokuBreak =
+            KinsokuProcessor.findBreakPoint(candidateText, breakIndex);
         if (kinsokuBreak > 0) breakIndex = kinsokuBreak;
       }
     }
 
-    // Fallback: no word boundary or CJK break was found. Split at the first
-    // character to avoid dropping the fragment entirely. Single-char text
-    // cannot be split further.
-    if (breakIndex <= 0 || breakIndex >= text.length) {
-      if (text.length > 1) {
-        breakIndex = 1;
-      } else {
-        return null;
+    // Fallback: a single word wider than the whole line. Break it after as
+    // many characters as fit (as Flutter's Text does) rather than after the
+    // first character, which used to leave a column of one-letter lines.
+    if (breakIndex <= 0) breakIndex = math.max(1, fitIndex);
+    if (breakIndex >= text.length) return null;
+
+    // Collapsible spaces at the wrap hang past the line end: keep them out of
+    // the next line's start (so its glyphs keep their character offsets).
+    final ws = style.whiteSpace;
+    final shouldTrim = !_isPreformattedWhiteSpace(ws);
+    if (shouldTrim) {
+      while (breakIndex < text.length && text[breakIndex] == ' ') {
+        breakIndex++;
       }
+      if (breakIndex >= text.length) return null;
     }
 
     // Ensure breakIndex aligns with grapheme cluster boundaries.
-    if (breakIndex > 0 && breakIndex < text.length) {
-      final range = text.characters.iterator;
+    if (breakIndex > 0 && breakIndex < candidateText.length) {
+      final range = candidateText.characters.iterator;
       int currentOffset = 0;
       while (range.moveNext()) {
         int nextOffset = currentOffset + range.current.length;
@@ -1727,7 +2089,11 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
       }
     }
 
-    final firstPart = text.substring(0, breakIndex);
+    // The trailing space is not part of the line's width, so text-align
+    // centers / right-aligns the visible glyphs (as _splitTextFragment does).
+    final rawFirst = text.substring(0, breakIndex);
+    final trimmedFirst = shouldTrim ? rawFirst.trimRight() : rawFirst;
+    final firstPart = trimmedFirst.isEmpty ? rawFirst : trimmedFirst;
     final secondPart = text.substring(breakIndex);
 
     final firstFragment = Fragment.text(
@@ -1736,7 +2102,15 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
       style: fragment.style,
       characterOffset: fragment.characterOffset,
     )..globalOffset = fragment.globalOffset;
-    _measureFragment(firstFragment);
+
+    if (firstPart.length == breakIndex) {
+      final w = _prefixWidth(painter, breakIndex);
+      firstFragment.measuredSize = Size(w, painter.height);
+      firstFragment.baseline =
+          painter.computeDistanceToActualBaseline(TextBaseline.alphabetic);
+    } else {
+      _measureFragment(firstFragment);
+    }
 
     final secondFragment = Fragment.text(
       text: secondPart,
@@ -1744,7 +2118,15 @@ extension _RenderHyperBoxLayout on RenderHyperBox {
       style: fragment.style,
       characterOffset: fragment.characterOffset + breakIndex,
     )..globalOffset = fragment.globalOffset + breakIndex;
-    _measureFragment(secondFragment);
+
+    final safeContainerLimit =
+        _safeCandidateCharLimit(_maxWidth, fragment.style, isCjk: isCjk);
+    if (secondPart.length > safeContainerLimit) {
+      secondFragment.measuredSize = Size(double.infinity, firstFragment.height);
+      secondFragment.baseline = firstFragment.baseline;
+    } else {
+      _measureFragment(secondFragment);
+    }
 
     return (firstFragment, secondFragment);
   }
diff --git a/packages/hyper_render_core/lib/src/model/fragment.dart b/packages/hyper_render_core/lib/src/model/fragment.dart
index e347e1e..6d0dd10 100644
--- a/packages/hyper_render_core/lib/src/model/fragment.dart
+++ b/packages/hyper_render_core/lib/src/model/fragment.dart
@@ -66,6 +66,9 @@ class Fragment {
   /// Ruby annotation height (for proper layout)
   double? rubyHeight;
 
+  /// Distance from top of fragment to its alphabetic baseline (cached during measurement)
+  double? baseline;
+
   /// Number of leading characters from [text] that are actually visible after
   /// a CSS `text-overflow: ellipsis` truncation pass.
   ///
diff --git a/packages/hyper_render_core/lib/src/style/resolver.dart b/packages/hyper_render_core/lib/src/style/resolver.dart
index f0a148d..1078678 100644
--- a/packages/hyper_render_core/lib/src/style/resolver.dart
+++ b/packages/hyper_render_core/lib/src/style/resolver.dart
@@ -3488,6 +3488,11 @@ class StyleResolver {
     // White space - inherit if not explicitly set
     style.whiteSpace ??= parentStyle.whiteSpace;
 
+    // word-break / overflow-wrap inherit in CSS. Without this a value set on
+    // a <p> never reached its text nodes, which is where line breaking reads it.
+    style.wordBreak ??= parentStyle.wordBreak;
+    style.overflowWrap ??= parentStyle.overflowWrap;
+
     // border-collapse / border-spacing inherit in CSS (both apply only to
     // tables, but a value set on an ancestor cascades to nested tables).
     if (!style.isExplicitlySet('border-collapse')) {
diff --git a/packages/hyper_render_core/pubspec.yaml b/packages/hyper_render_core/pubspec.yaml
index 391badf..edaffaa 100644
--- a/packages/hyper_render_core/pubspec.yaml
+++ b/packages/hyper_render_core/pubspec.yaml
@@ -1,6 +1,6 @@
 name: hyper_render_core
 description: Core engine for HyperRender. Universal Document Tree, single-RenderObject layout with CSS float, Flexbox, Grid, CJK typography, AI streaming, and crash-free text selection.
-version: 1.12.0
+version: 1.13.0
 homepage: https://github.com/brewkits/hyper_render
 repository: https://github.com/brewkits/hyper_render/tree/main/packages/hyper_render_core
 issue_tracker: https://github.com/brewkits/hyper_render/issues
diff --git a/pubspec.yaml b/pubspec.yaml
index baedc2b..d5cbd56 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,6 +1,6 @@
 name: hyper_render
 description: "The only Flutter HTML/Markdown renderer with CSS float layout, crash-free text selection at any document size, CJK Ruby typography, and AI/LLM token streaming."
-version: 1.12.0
+version: 1.13.0
 homepage: https://github.com/brewkits/hyper_render
 repository: https://github.com/brewkits/hyper_render
 issue_tracker: https://github.com/brewkits/hyper_render/issues
@@ -45,7 +45,7 @@ dependencies:
   # hyper_render_html / _markdown / _highlight were declared but never imported
   # — pure install weight for every consumer. They remain separately published;
   # depend on them explicitly if you import them.
-  hyper_render_core: ^1.12.0
+  hyper_render_core: ^1.13.0
 
   # Fixed version constraints for pub.dev compliance
   flutter_highlight: ^0.7.0
diff --git a/test/golden/goldens/blockquote.png b/test/golden/goldens/blockquote.png
index 4e9de71..8e088cb 100644
Binary files a/test/golden/goldens/blockquote.png and b/test/golden/goldens/blockquote.png differ
diff --git a/test/golden/goldens/cjk_kinsoku.png b/test/golden/goldens/cjk_kinsoku.png
index f247cdf..92a9cb2 100644
Binary files a/test/golden/goldens/cjk_kinsoku.png and b/test/golden/goldens/cjk_kinsoku.png differ
diff --git a/test/golden/goldens/cjk_ruby.png b/test/golden/goldens/cjk_ruby.png
index 8d6261a..7f86198 100644
Binary files a/test/golden/goldens/cjk_ruby.png and b/test/golden/goldens/cjk_ruby.png differ
diff --git a/test/golden/goldens/definition_list.png b/test/golden/goldens/definition_list.png
index 549ceee..562f748 100644
Binary files a/test/golden/goldens/definition_list.png and b/test/golden/goldens/definition_list.png differ
diff --git a/test/golden/goldens/float_cjk.png b/test/golden/goldens/float_cjk.png
index 484422f..fa2eb29 100644
Binary files a/test/golden/goldens/float_cjk.png and b/test/golden/goldens/float_cjk.png differ
diff --git a/test/golden/goldens/float_clear.png b/test/golden/goldens/float_clear.png
index 78600d0..4b56314 100644
Binary files a/test/golden/goldens/float_clear.png and b/test/golden/goldens/float_clear.png differ
diff --git a/test/golden/goldens/float_left.png b/test/golden/goldens/float_left.png
index abdefaa..9c47edf 100644
Binary files a/test/golden/goldens/float_left.png and b/test/golden/goldens/float_left.png differ
diff --git a/test/golden/goldens/full_article.png b/test/golden/goldens/full_article.png
index 9b4e2a8..09b0c48 100644
Binary files a/test/golden/goldens/full_article.png and b/test/golden/goldens/full_article.png differ
diff --git a/test/golden/goldens/headings.png b/test/golden/goldens/headings.png
index 451a454..cc82d1e 100644
Binary files a/test/golden/goldens/headings.png and b/test/golden/goldens/headings.png differ
diff --git a/test/golden/goldens/image_placeholder.png b/test/golden/goldens/image_placeholder.png
index 9ae7316..fa029d5 100644
Binary files a/test/golden/goldens/image_placeholder.png and b/test/golden/goldens/image_placeholder.png differ
diff --git a/test/golden/goldens/links.png b/test/golden/goldens/links.png
index 761a71d..58c4b2b 100644
Binary files a/test/golden/goldens/links.png and b/test/golden/goldens/links.png differ
diff --git a/test/golden/goldens/mixed_inline.png b/test/golden/goldens/mixed_inline.png
index f26d19c..14a1688 100644
Binary files a/test/golden/goldens/mixed_inline.png and b/test/golden/goldens/mixed_inline.png differ
diff --git a/test/golden/goldens/rtl_arabic.png b/test/golden/goldens/rtl_arabic.png
index b0c56b0..b030b43 100644
Binary files a/test/golden/goldens/rtl_arabic.png and b/test/golden/goldens/rtl_arabic.png differ
diff --git a/test/golden/goldens/rtl_hebrew.png b/test/golden/goldens/rtl_hebrew.png
index a2a74cb..203ad91 100644
Binary files a/test/golden/goldens/rtl_hebrew.png and b/test/golden/goldens/rtl_hebrew.png differ
diff --git a/test/golden/goldens/text_formatting.png b/test/golden/goldens/text_formatting.png
index 245aaa3..c1b738e 100644
Binary files a/test/golden/goldens/text_formatting.png and b/test/golden/goldens/text_formatting.png differ
diff --git a/test/line_breaking_perf_and_parity_test.dart b/test/line_breaking_perf_and_parity_test.dart
new file mode 100644
index 0000000..f836c9b
--- /dev/null
+++ b/test/line_breaking_perf_and_parity_test.dart
@@ -0,0 +1,681 @@
+// ignore_for_file: avoid_print
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:hyper_render/hyper_render.dart';
+import 'package:hyper_render_core/hyper_render_core.dart'
+    show HyperRenderDebugHooks;
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  // Synthetic unspaced CJK sample (100 characters)
+  const cjkSample =
+      '此開卷第一回也作者自云因曾歷過一番夢幻之后故將真事隱去而借通靈之說撰此石頭記一書也故曰甄士隱云云但書中所記何事何人自又云今風塵碌碌一事無成忽念及當日所有之女子一一細考較去覺其行止見識皆出于我之上';
+
+  group('Group 1: Intrinsic Widths in Shrink-to-Fit Contexts', () {
+    testWidgets(
+        'getMinIntrinsicWidth and getMaxIntrinsicWidth for long unspaced CJK fragment',
+        (WidgetTester tester) async {
+      // 1,000 characters of unspaced CJK
+      final longText = cjkSample * 10;
+
+      RenderHyperBox? hyperBox;
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: HyperRenderWidget(
+            document: DocumentNode(
+              children: [
+                BlockNode(
+                  tagName: 'p',
+                  children: [TextNode(longText)],
+                ),
+              ],
+            ),
+          ),
+        ),
+      );
+
+      final renderObject = tester.renderObject(find.byType(HyperRenderWidget));
+      if (renderObject is RenderHyperBox) {
+        hyperBox = renderObject;
+      }
+      expect(hyperBox, isNotNull);
+
+      // CJK characters can break after each character. Min intrinsic width is
+      // the width of a single character (~16px), not the full 1,000 chars.
+      final minWidth = hyperBox!.getMinIntrinsicWidth(double.infinity);
+      expect(minWidth, greaterThan(10.0));
+      expect(minWidth, lessThan(30.0));
+
+      // Max intrinsic width represents unwrapped single-line text width.
+      // 1,000 CJK characters at default font size (16px) should be ~16,000px.
+      // Must NOT be truncated or clamped to layout maxWidth.
+      final maxWidth = hyperBox.getMaxIntrinsicWidth(double.infinity);
+      expect(maxWidth, greaterThan(10000.0));
+    });
+
+    testWidgets('Shrink-to-fit context: table cell with unspaced CJK text',
+        (WidgetTester tester) async {
+      final text = cjkSample * 2; // 200 chars
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: MaterialApp(
+            home: Scaffold(
+              body: Center(
+                child: SizedBox(
+                  width: 500,
+                  child: HyperRenderWidget(
+                    document: DocumentNode(
+                      children: [
+                        BlockNode(
+                          tagName: 'table',
+                          style: ComputedStyle(width: 500),
+                          children: [
+                            BlockNode(
+                              tagName: 'tr',
+                              children: [
+                                BlockNode(
+                                  tagName: 'td',
+                                  children: [TextNode(text)],
+                                ),
+                              ],
+                            ),
+                          ],
+                        ),
+                      ],
+                    ),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final renderObject =
+          tester.renderObject(find.byType(HyperRenderWidget)) as RenderHyperBox;
+      expect(renderObject.hasSize, isTrue);
+      expect(renderObject.size.width, equals(500.0));
+      expect(renderObject.size.height, greaterThan(0.0));
+    });
+
+    testWidgets(
+        'Shrink-to-fit context: inline-block container with unspaced CJK text',
+        (WidgetTester tester) async {
+      final text = cjkSample * 2;
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: MaterialApp(
+            home: Scaffold(
+              body: Center(
+                child: SizedBox(
+                  width: 600,
+                  child: HyperRenderWidget(
+                    document: DocumentNode(
+                      children: [
+                        BlockNode(
+                          tagName: 'div',
+                          style:
+                              ComputedStyle(display: DisplayType.inlineBlock),
+                          children: [TextNode(text)],
+                        ),
+                      ],
+                    ),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final renderObject =
+          tester.renderObject(find.byType(HyperRenderWidget)) as RenderHyperBox;
+      expect(renderObject.hasSize, isTrue);
+      expect(renderObject.size.height, greaterThan(0.0));
+      final lines = renderObject.debugLines();
+      expect(lines.length, greaterThan(1));
+    });
+  });
+
+  group('Group 2: Fast-Path Parity & Edge Case Coverage', () {
+    testWidgets('Plain text wrapping parity', (WidgetTester tester) async {
+      final text = cjkSample * 3; // 300 chars
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: SizedBox(
+              width: 400,
+              child: HyperRenderWidget(
+                document: DocumentNode(
+                  children: [
+                    BlockNode(
+                      tagName: 'p',
+                      children: [TextNode(text)],
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final box =
+          tester.renderObject(find.byType(HyperRenderWidget)) as RenderHyperBox;
+      final lines = box.debugLines();
+      expect(lines.length, greaterThan(5));
+      for (final line in lines) {
+        expect(line['width'] as double, lessThanOrEqualTo(400.0));
+        expect(line['height'] as double, greaterThan(0.0));
+      }
+    });
+
+    testWidgets('text-align: justify layout', (WidgetTester tester) async {
+      const latinText =
+          'The quick brown fox jumps over the lazy dog and runs through the forest with great speed and agility. '
+          'Every single animal in the meadow stopped to watch the astonishing performance of the graceful creatures.';
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: SizedBox(
+              width: 300,
+              child: HyperRenderWidget(
+                document: DocumentNode(
+                  children: [
+                    BlockNode(
+                      tagName: 'p',
+                      style: ComputedStyle(textAlign: HyperTextAlign.justify),
+                      children: [TextNode(latinText)],
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final box =
+          tester.renderObject(find.byType(HyperRenderWidget)) as RenderHyperBox;
+      final lines = box.debugLines();
+      expect(lines.length, greaterThan(2));
+      // First line width within container
+      expect(lines.first['width'] as double, lessThanOrEqualTo(300.0));
+    });
+
+    testWidgets(
+        'text-overflow: ellipsis truncates on single line and does not multi-line wrap',
+        (WidgetTester tester) async {
+      final text = cjkSample * 5;
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: SizedBox(
+              width: 300,
+              child: HyperRenderWidget(
+                document: DocumentNode(
+                  children: [
+                    BlockNode(
+                      tagName: 'p',
+                      style: ComputedStyle(
+                        textOverflow: TextOverflow.ellipsis,
+                        whiteSpace: 'nowrap',
+                      ),
+                      children: [TextNode(text)],
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final box =
+          tester.renderObject(find.byType(HyperRenderWidget)) as RenderHyperBox;
+      final lines = box.debugLines();
+      // Ellipsis nowrap must remain on 1 single line
+      expect(lines.length, equals(1));
+      final lineFrags = box.debugLineFragments();
+      expect(lineFrags, isNotEmpty);
+      expect(
+          lineFrags.any((f) => (f['text'] as String?)?.contains('…') ?? false),
+          isTrue);
+    });
+
+    testWidgets('non-default textScaler scaling', (WidgetTester tester) async {
+      final text = cjkSample * 2;
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: MediaQuery(
+              data: const MediaQueryData(textScaler: TextScaler.linear(1.5)),
+              child: SizedBox(
+                width: 400,
+                child: HyperRenderWidget(
+                  document: DocumentNode(
+                    children: [
+                      BlockNode(
+                        tagName: 'p',
+                        children: [TextNode(text)],
+                      ),
+                    ],
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final box =
+          tester.renderObject(find.byType(HyperRenderWidget)) as RenderHyperBox;
+      final lines = box.debugLines();
+      expect(lines.length, greaterThan(3));
+      // At 1.5x scale, line height is noticeably larger than baseline 16px font
+      expect(lines.first['height'] as double, greaterThan(20.0));
+    });
+
+    testWidgets('mixed CJK and Latin text wrapping',
+        (WidgetTester tester) async {
+      const mixedText =
+          '第一章 Introduction to Ancient Stones. 在古代中國，這是一段測試文本，including various English terms, numbers 12345, '
+          'and mixed punctuation！更多詳細內容請參見後續章節。';
+      final text = mixedText * 3;
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: SizedBox(
+              width: 350,
+              child: HyperRenderWidget(
+                document: DocumentNode(
+                  children: [
+                    BlockNode(
+                      tagName: 'p',
+                      children: [TextNode(text)],
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final box =
+          tester.renderObject(find.byType(HyperRenderWidget)) as RenderHyperBox;
+      final lines = box.debugLines();
+      expect(lines.length, greaterThan(3));
+      for (final line in lines) {
+        expect(line['width'] as double, lessThanOrEqualTo(350.0));
+      }
+    });
+
+    testWidgets(
+        'float starting partway through paragraph triggers fallback path properly',
+        (WidgetTester tester) async {
+      // Paragraph with lead-in text, a floating box, then trailing text
+      const textBefore = cjkSample;
+      final textAfter = cjkSample * 2;
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: SizedBox(
+              width: 500,
+              child: HyperRenderWidget(
+                document: DocumentNode(
+                  children: [
+                    BlockNode(
+                      tagName: 'p',
+                      children: [
+                        TextNode(textBefore),
+                        AtomicNode(
+                          tagName: 'img',
+                          style: ComputedStyle(
+                            float: HyperFloat.left,
+                            width: 100,
+                            height: 80,
+                          ),
+                        ),
+                        TextNode(textAfter),
+                      ],
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final box =
+          tester.renderObject(find.byType(HyperRenderWidget)) as RenderHyperBox;
+      expect(box.hasSize, isTrue);
+      final lines = box.debugLines();
+      expect(lines.length, greaterThan(5));
+      // Text alongside 100px float wraps narrower (width <= 400.0) than the full 500px container
+      expect(lines.any((l) => (l['width'] as double) <= 400.0), isTrue);
+    });
+
+    testWidgets(
+        'text after an inline lead-in wraps into multiple lines without single-line tail overflow (Latin & CJK)',
+        (WidgetTester tester) async {
+      final samples = <String, String>{
+        'Latin':
+            '<p><b>Note:</b> ${'lorem ipsum dolor sit amet consectetur ' * 10}</p>',
+        'CJK': '<p><b>注意：</b>${'日本語のテキストは行末で適切に折り返される必要があります。' * 6}</p>',
+      };
+
+      for (final entry in samples.entries) {
+        await tester.pumpWidget(
+          Directionality(
+            textDirection: TextDirection.ltr,
+            child: Center(
+              child: SizedBox(
+                width: 300,
+                child:
+                    HyperViewer(html: entry.value, mode: HyperRenderMode.sync),
+              ),
+            ),
+          ),
+        );
+        await tester.pump(const Duration(milliseconds: 50));
+
+        final box = tester.renderObject(find.byType(HyperRenderWidget).first)
+            as RenderHyperBox;
+        final lines = box.debugLines();
+        expect(lines.length, greaterThan(4),
+            reason:
+                '${entry.key} text after lead-in must wrap into multiple lines');
+
+        final frags =
+            box.debugLineFragments().where((f) => f['type'] == 'text').toList();
+        for (final f in frags) {
+          final text = (f['text'] as String).trimRight();
+          final painter = TextPainter(
+            text: TextSpan(
+              text: text,
+              style: const TextStyle(fontSize: 16),
+            ),
+            textDirection: TextDirection.ltr,
+          )..layout();
+          final x = f['offsetX'] as double;
+          expect(
+            x + painter.width,
+            lessThanOrEqualTo(300.5),
+            reason:
+                '${entry.key} line fragment "${f['text']}" on line ${f['lineIndex']} runs past the box (x: $x, width: ${painter.width})',
+          );
+        }
+      }
+    });
+  });
+
+  group('Group 3: Selection and Hit-Testing Continuity', () {
+    testWidgets('globalOffset continuity across sliced line fragments',
+        (WidgetTester tester) async {
+      final text = cjkSample * 3; // 300 chars
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: SizedBox(
+              width: 350,
+              child: HyperRenderWidget(
+                document: DocumentNode(
+                  children: [
+                    BlockNode(
+                      tagName: 'p',
+                      children: [TextNode(text)],
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final box =
+          tester.renderObject(find.byType(HyperRenderWidget)) as RenderHyperBox;
+      final fragments = box.debugLineFragments();
+      expect(fragments.length, greaterThan(3));
+
+      // Verify strict continuity: fragment[i].charEnd == fragment[i+1].charStart
+      int expectedOffset = 0;
+      for (var i = 0; i < fragments.length; i++) {
+        final frag = fragments[i];
+        final start = frag['charStart'] as int;
+        final end = frag['charEnd'] as int;
+        expect(start, equals(expectedOffset),
+            reason:
+                'Fragment $i charStart should match prior offset with zero gaps');
+        expect(end, greaterThan(start));
+        expectedOffset = end;
+      }
+      expect(expectedOffset, equals(text.length));
+    });
+
+    testWidgets('getBoxesForCharRange across line boundaries',
+        (WidgetTester tester) async {
+      final text = cjkSample * 2;
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: SizedBox(
+              width: 300,
+              child: HyperRenderWidget(
+                document: DocumentNode(
+                  children: [
+                    BlockNode(
+                      tagName: 'p',
+                      children: [TextNode(text)],
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final box =
+          tester.renderObject(find.byType(HyperRenderWidget)) as RenderHyperBox;
+      // Select characters 10 through 60 (spanning across lines)
+      final boxes = box.getBoxesForCharRange(10, 60);
+      expect(boxes, isNotEmpty);
+      expect(boxes.length, greaterThanOrEqualTo(2),
+          reason:
+              'Range crossing line boundary must produce boxes for each line');
+      for (final rect in boxes) {
+        expect(rect.width, greaterThan(0.0));
+        expect(rect.height, greaterThan(0.0));
+      }
+    });
+
+    testWidgets('getSelectedText returns exact unbroken substring',
+        (WidgetTester tester) async {
+      final text = cjkSample * 2;
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: SizedBox(
+              width: 300,
+              child: HyperRenderWidget(
+                selectable: true,
+                document: DocumentNode(
+                  children: [
+                    BlockNode(
+                      tagName: 'p',
+                      children: [TextNode(text)],
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final box =
+          tester.renderObject(find.byType(HyperRenderWidget)) as RenderHyperBox;
+      box.startSelectionAt(const Offset(10, 10));
+      box.extendSelectionTo(const Offset(250, 80));
+
+      final selected = box.getSelectedText();
+      expect(selected, isNotNull);
+      expect(selected!.isNotEmpty, isTrue);
+      // The extracted text must be a genuine substring of the source text
+      expect(text.contains(selected), isTrue);
+    });
+  });
+
+  group('Group 4: Deterministic Performance Test (CI-Safe)', () {
+    testWidgets(
+        'TextPainter.layout call-counting on 50-line unspaced paragraph',
+        (WidgetTester tester) async {
+      final text = cjkSample * 15; // ~1,500 characters, ~50 lines
+
+      int lineLayoutCalls = 0;
+      HyperRenderDebugHooks.onLineLayoutTextPainter = () {
+        lineLayoutCalls++;
+      };
+
+      try {
+        await tester.pumpWidget(
+          Directionality(
+            textDirection: TextDirection.ltr,
+            child: Center(
+              child: SizedBox(
+                width: 500,
+                child: HyperRenderWidget(
+                  document: DocumentNode(
+                    children: [
+                      BlockNode(
+                        tagName: 'p',
+                        children: [TextNode(text)],
+                      ),
+                    ],
+                  ),
+                ),
+              ),
+            ),
+          ),
+        );
+
+        final box = tester.renderObject(find.byType(HyperRenderWidget))
+            as RenderHyperBox;
+        final lines = box.debugLines();
+        expect(lines.length, greaterThan(35));
+
+        // In the old O(N^2) line-by-line breaker, lineLayoutCalls was >= lines.length (40-50+ calls).
+        // Under the native multi-line fast path, lineLayoutCalls is exactly 1 (single multiPainter.layout call)!
+        expect(lineLayoutCalls, equals(1),
+            reason:
+                'Native multi-line fast path must perform exactly 1 TextPainter pass for line breaking');
+      } finally {
+        HyperRenderDebugHooks.onLineLayoutTextPainter = null;
+      }
+    });
+
+    testWidgets(
+        'Scaling ratio between N and 2N demonstrates linear O(N) scaling',
+        (WidgetTester tester) async {
+      // Compare 1,500 characters (N) vs 3,000 characters (2N)
+      final textN = cjkSample * 15; // 1,500 chars
+      final text2N = cjkSample * 30; // 3,000 chars
+
+      int callsN = 0;
+      int calls2N = 0;
+
+      // Reset cache before measuring N so tests are independent of earlier runs
+      RenderHyperBox.setGlobalTextCacheSize(1);
+      RenderHyperBox.setGlobalTextCacheSize(5000);
+
+      HyperRenderDebugHooks.onTextPainterLayout = () => callsN++;
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: SizedBox(
+              width: 500,
+              child: HyperRenderWidget(
+                key: const ValueKey('N'),
+                document: DocumentNode(
+                  children: [
+                    BlockNode(
+                      tagName: 'p',
+                      children: [TextNode(textN)],
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+      HyperRenderDebugHooks.onTextPainterLayout = null;
+
+      // Reset cache before measuring 2N
+      RenderHyperBox.setGlobalTextCacheSize(1);
+      RenderHyperBox.setGlobalTextCacheSize(5000);
+
+      HyperRenderDebugHooks.onTextPainterLayout = () => calls2N++;
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: SizedBox(
+              width: 500,
+              child: HyperRenderWidget(
+                key: const ValueKey('2N'),
+                document: DocumentNode(
+                  children: [
+                    BlockNode(
+                      tagName: 'p',
+                      children: [TextNode(text2N)],
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+      HyperRenderDebugHooks.onTextPainterLayout = null;
+
+      // In an O(N) linear line-breaker, doubling the input (N -> 2N) roughly doubles operations (ratio ~2.0).
+      // In an O(N^2) quadratic line-breaker, doubling the input quadruples operations (ratio >= 3.5 - 4.0).
+      expect(callsN, greaterThan(0));
+      expect(calls2N, greaterThan(0));
+      final ratio = calls2N / callsN;
+      expect(ratio, inInclusiveRange(1.5, 2.5),
+          reason:
+              'Scaling ratio ($ratio) between N ($callsN calls) and 2N ($calls2N calls) must be linear O(N) (~2.0), not quadratic O(N^2)');
+    });
+  });
+}
diff --git a/test/line_breaking_regression_test.dart b/test/line_breaking_regression_test.dart
new file mode 100644
index 0000000..0d925e7
--- /dev/null
+++ b/test/line_breaking_regression_test.dart
@@ -0,0 +1,253 @@
+// Line-breaking regressions found while reviewing #29: on a 300px box the
+// wrapped lines must stay inside the box, RTL text must wrap, `word-break`
+// must inherit, centered lines must center their visible glyphs, and a word
+// that does not fit beside a float must move below it.
+//
+// The test font is Ahem: every glyph is a 16px square at the default size, so
+// a line's visible width is predictable and measured independently here.
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:hyper_render/hyper_render.dart';
+
+const double _boxWidth = 300;
+
+Future<RenderHyperBox> _pump(WidgetTester tester, String html) async {
+  await tester.pumpWidget(MaterialApp(
+    home: Scaffold(
+      body: SizedBox(
+        width: _boxWidth,
+        child: HyperViewer(html: html, mode: HyperRenderMode.sync),
+      ),
+    ),
+  ));
+  await tester.pump(const Duration(milliseconds: 50));
+  return tester.renderObject<RenderHyperBox>(
+    find.byType(HyperRenderWidget).first,
+  );
+}
+
+List<Map<String, dynamic>> _textLines(RenderHyperBox box) =>
+    box.debugLineFragments().where((f) => f['type'] == 'text').toList();
+
+/// Width of [text] without its trailing spaces, measured from scratch rather
+/// than trusting the fragment's own reported width.
+double _visibleWidth(String text) {
+  final painter = TextPainter(
+    text: TextSpan(
+      text: text.trimRight(),
+      style: const TextStyle(fontSize: 16),
+    ),
+    textDirection: TextDirection.ltr,
+  )..layout();
+  return painter.width;
+}
+
+String _words(int count) => List.generate(
+      count,
+      (i) => const [
+        'lorem',
+        'ipsum',
+        'dolor',
+        'sit',
+        'amet',
+        'consectetur'
+      ][i % 6],
+    ).join(' ');
+
+void main() {
+  group('Line breaking stays inside the box', () {
+    final samples = <String, String>{
+      'latin': '<p>${_words(40)}</p>',
+      'cjk': '<p>${'日本語のテキストは行末で適切に折り返される必要があります' * 4}</p>',
+      'rtl':
+          '<p style="direction:rtl">${'هذا نص عربي طويل يجب أن يلتف ' * 4}</p>',
+      'text after an inline element': '<p><b>Note:</b> ${_words(40)}</p>',
+      'cjk after an inline element':
+          '<p><b>注意：</b>${'日本語のテキストは行末で適切に' * 6}</p>',
+      'beside a float': '<div><img src="x" '
+          'style="float:left;width:120px;height:40px">${_words(40)}</div>',
+      'break-all': '<p style="word-break:break-all">'
+          'Supercalifragilistic expialidocious antidisestablishmentarianism</p>',
+    };
+
+    for (final entry in samples.entries) {
+      testWidgets(entry.key, (tester) async {
+        final box = await _pump(tester, entry.value);
+        final lines = _textLines(box);
+        expect(lines.length, greaterThan(2), reason: 'sample should wrap');
+        for (final f in lines) {
+          final x = f['offsetX'] as double;
+          final text = f['text'] as String;
+          expect(
+            x + _visibleWidth(text),
+            lessThanOrEqualTo(_boxWidth + 0.5),
+            reason: 'line ${f['lineIndex']} "$text" runs past the box',
+          );
+        }
+      });
+    }
+  });
+
+  testWidgets('RTL paragraph wraps without one-glyph lines', (tester) async {
+    final box = await _pump(
+      tester,
+      '<p style="direction:rtl">${'هذا نص عربي طويل يجب أن يلتف ' * 4}</p>',
+    );
+    final lines = _textLines(box);
+    // 116 chars at 18 glyphs per line: at least 7 lines, none of them a lone
+    // glyph (the old x-probe read the RTL painter from the wrong end).
+    expect(lines.length, greaterThanOrEqualTo(7));
+    for (final f in lines.take(lines.length - 1)) {
+      expect((f['text'] as String).trim().length, greaterThan(8));
+    }
+  });
+
+  testWidgets('word-break: break-all on <p> reaches its text and fills lines',
+      (tester) async {
+    const text = 'consectetur consectetur consectetur consectetur';
+    final normal = _textLines(await _pump(tester, '<p>$text</p>'));
+    // Without break-all each 11-char word fits a line but two do not.
+    expect(normal.first['text'], 'consectetur');
+
+    final box = await _pump(
+      tester,
+      '<p style="word-break:break-all">$text</p>',
+    );
+    final lines = _textLines(box);
+    // break-all fills each line to 18 glyphs, mid-word. It used to be ignored
+    // because word-break was not inherited from the <p> by its text node.
+    expect(lines.first['text'], 'consectetur consec');
+    expect(lines.length, 3);
+  });
+
+  testWidgets('a word wider than the line breaks after as many chars as fit',
+      (tester) async {
+    final box = await _pump(
+      tester,
+      '<p>pneumonoultramicroscopicsilicovolcanoconiosis</p>',
+    );
+    final lines = _textLines(box);
+    expect(lines.first['text'], 'pneumonoultramicro');
+    expect((lines.first['text'] as String).length, 18);
+  });
+
+  testWidgets('centered lines center their visible glyphs', (tester) async {
+    final box = await _pump(
+      tester,
+      '<p style="text-align:center">${_words(20)}</p>',
+    );
+    for (final f in _textLines(box)) {
+      final x = f['offsetX'] as double;
+      final text = f['text'] as String;
+      expect(text, isNot(endsWith(' ')));
+      expect(x * 2 + _visibleWidth(text), closeTo(_boxWidth, 1.0),
+          reason: '"$text" is off-center');
+    }
+  });
+
+  testWidgets('a word that does not fit beside a float moves below it',
+      (tester) async {
+    final box = await _pump(
+      tester,
+      '<div><img src="x" style="float:left;width:120px;height:40px">'
+      '${_words(40)}</div>',
+    );
+    final lines = _textLines(box);
+    // "consectetur" (176px) does not fit in the 172px beside the float. It
+    // used to be split as "c" / "onsectetur". Every line must hold whole words.
+    const vocabulary = {
+      'lorem',
+      'ipsum',
+      'dolor',
+      'sit',
+      'amet',
+      'consectetur'
+    };
+    for (final f in lines) {
+      for (final word in (f['text'] as String).trim().split(' ')) {
+        expect(vocabulary, contains(word),
+            reason: 'line ${f['lineIndex']} splits a word: "${f['text']}"');
+      }
+    }
+    // The first "consectetur" starts the first line below the float.
+    final word = lines.firstWhere(
+      (f) => (f['text'] as String).contains('consectetur'),
+    );
+    expect((word['text'] as String).startsWith('consectetur'), isTrue);
+    expect(word['offsetX'], 0.0);
+    expect(word['lineTop'] as double, greaterThanOrEqualTo(40.0));
+  });
+
+  testWidgets('copying across a wrapped line keeps the space', (tester) async {
+    const html = '<p>The quick brown fox jumps over the lazy dog again '
+        'and again and again until the line has wrapped twice.</p>';
+    final box = await _pump(tester, html);
+    final lines = _textLines(box);
+    final firstLineText = (lines.first['text'] as String).trimRight();
+    expect(firstLineText, isNot(endsWith(' ')));
+    box.selection = const HyperTextSelection(start: 0, end: 30);
+    expect(box.getSelectedText(), 'The quick brown fox jumps over');
+  });
+
+  testWidgets('spaces at the start of a line are removed', (tester) async {
+    final box = await _pump(
+      tester,
+      '<p>\n   first line<br>   second line<br> <b>third</b></p>'
+      // "Bold with nested" is 16 glyphs, so " inside" moves whole to the
+      // next line, which must not start with its space.
+      '<p><b>Bold with <i>nested</i> inside</b> and back</p>',
+    );
+    final lines = _textLines(box);
+    for (final f in lines.where((f) => f['offsetX'] == 0.0)) {
+      expect((f['text'] as String).startsWith(' '), isFalse,
+          reason: 'line ${f['lineIndex']} starts with a space');
+    }
+    expect(lines.map((f) => f['text']),
+        containsAll(['first line', 'second line', 'third', 'inside']));
+  });
+
+  testWidgets('right-aligned lines end flush, ignoring the trailing space',
+      (tester) async {
+    final box = await _pump(
+      tester,
+      '<p style="text-align:right">short line \n</p>',
+    );
+    final f = _textLines(box).single;
+    final x = f['offsetX'] as double;
+    expect(x + _visibleWidth(f['text'] as String), closeTo(_boxWidth, 0.5));
+    expect(f['text'], 'short line');
+  });
+
+  testWidgets('text-overflow: ellipsis works on the first block of a document',
+      (tester) async {
+    // No preceding block, margin or padding: this block used to emit no
+    // block-start fragment, so ellipsisDepth never rose and the text wrapped.
+    final box = await _pump(
+      tester,
+      '<div style="overflow:hidden;text-overflow:ellipsis;'
+      'white-space:nowrap">${_words(20)}</div>',
+    );
+    final lines = _textLines(box);
+    expect(lines, hasLength(1));
+    expect(lines.single['text'] as String, endsWith('\u2026'));
+    expect(
+      (lines.single['offsetX'] as double) +
+          _visibleWidth(lines.single['text'] as String),
+      lessThanOrEqualTo(_boxWidth + 0.5),
+    );
+  });
+
+  testWidgets('a floated block does not add a phantom line height',
+      (tester) async {
+    const text = 'One two three four five six seven eight nine ten';
+    final box = await _pump(
+      tester,
+      '<div style="float:left;width:150px">$text</div><p>$text</p>',
+    );
+    // Known gap: the floated div's text is laid out in normal flow. Its first
+    // line must be one text line tall (16px at Ahem), not 24.
+    final lines = _textLines(box);
+    expect(lines[1]['lineTop'], 16.0);
+  });
+}