diff --git a/render-wasm/docs/cjk-layout.md b/render-wasm/docs/cjk-layout.md
index 28a6a41a83..cd26831db4 100644
--- a/render-wasm/docs/cjk-layout.md
+++ b/render-wasm/docs/cjk-layout.md
@@ -53,10 +53,17 @@ Their offset maps therefore stay identical for drawing, hit testing, carets,
 selection, text paths and export. Width participates in the plan cache key;
 resizing a box restores whole-word joins when the word fits again.
 
-A horizontal indivisible unit wider than the entire box remains subject to
-SkParagraph's last-resort fallback. Very narrow boxes containing punctuation
-or annotation units need further work; this implementation does not claim
-complete CSS `keep-all` conformance.
+If an indivisible Chinese or Korean punctuation/annotation unit exceeds the
+box width, the plan lets it overflow together. It first measures surrounding
+text at the original width, then records those line starts with layout-only
+line separators before giving Skia enough physical width for the unit.
+Ordinary text keeps its original wrap budget. Source text stays unchanged;
+the plan's offset map accounts for every inserted separator.
+
+Painting, strokes, caret/selection geometry, hit testing, annotations, paths
+and exports share the plan and its alignment offset. The width cache also
+rebuilds these breaks on resize. Legacy Korean `spaces-only` keeps its earlier
+behavior; the supported modes do not claim complete CSS `keep-all` conformance.
 
 ## Pinyin readings
 
@@ -132,7 +139,7 @@ mode. Both WASM consumers use the same writer and byte values: 0 syllable,
 
 Real Pinyin, Zhuyin and Korean IME checks and native-reader review remain
 release checks. Font glyph coverage and localized forms still depend on the
-chosen fonts. Dedicated Zhuyin layout remains a Stage 4 follow-up.
+chosen fonts. Dedicated Zhuyin layout is described below.
 
 References checked on 2026-10-19:
 
diff --git a/render-wasm/src/globals.rs b/render-wasm/src/globals.rs
index b9045f1d89..228284c385 100644
--- a/render-wasm/src/globals.rs
+++ b/render-wasm/src/globals.rs
@@ -56,17 +56,30 @@ pub(crate) fn has_render_state() -> bool {
     unsafe { !RENDER_STATE.is_null() }
 }
 
+/// The render resources in use: in tests, the ones this thread installed with
+/// [`TestRenderResourcesGuard`], else the global ones.
+#[inline(always)]
+fn render_resources() -> *mut RenderResources {
+    #[cfg(test)]
+    {
+        let installed = TEST_RENDER_RESOURCES.with(std::cell::Cell::get);
+        if !installed.is_null() {
+            return installed;
+        }
+    }
+    unsafe { RENDER_RESOURCES }
+}
+
 #[inline(always)]
 pub(crate) fn has_render_resources() -> bool {
-    unsafe { !RENDER_RESOURCES.is_null() }
+    !render_resources().is_null()
 }
 
 #[inline(always)]
 pub(crate) fn get_resources() -> &'static mut RenderResources {
-    unsafe {
-        debug_assert!(!RENDER_RESOURCES.is_null(), "Render Resources is null");
-        &mut *RENDER_RESOURCES
-    }
+    let resources = render_resources();
+    debug_assert!(!resources.is_null(), "Render Resources is null");
+    unsafe { &mut *resources }
 }
 
 #[inline(always)]
@@ -120,7 +133,16 @@ macro_rules! with_current_shape {
     };
 }
 
-/// Scoped override of the global render resources pointer for unit tests.
+#[cfg(test)]
+thread_local! {
+    /// Render resources a test installed for its own thread. Tests run on
+    /// parallel threads, and Skia font collections are not thread-safe, so
+    /// another test must never reach them.
+    static TEST_RENDER_RESOURCES: std::cell::Cell<*mut RenderResources> =
+        const { std::cell::Cell::new(std::ptr::null_mut()) };
+}
+
+/// Scoped override of the render resources for the current test thread.
 #[cfg(test)]
 pub(crate) struct TestRenderResourcesGuard {
     prev: *mut RenderResources,
@@ -136,8 +158,7 @@ impl TestRenderResourcesGuard {
         let lock = TEST_RENDER_RESOURCES_LOCK
             .lock()
             .unwrap_or_else(|poisoned| poisoned.into_inner());
-        let prev = unsafe { RENDER_RESOURCES };
-        unsafe { RENDER_RESOURCES = resources as *mut _ };
+        let prev = TEST_RENDER_RESOURCES.replace(resources as *mut _);
         Self { prev, _lock: lock }
     }
 }
@@ -145,7 +166,7 @@ impl TestRenderResourcesGuard {
 #[cfg(test)]
 impl Drop for TestRenderResourcesGuard {
     fn drop(&mut self) {
-        unsafe { RENDER_RESOURCES = self.prev };
+        TEST_RENDER_RESOURCES.set(self.prev);
     }
 }
 
diff --git a/render-wasm/src/render/text.rs b/render-wasm/src/render/text.rs
index 16f6954b73..375de96b5d 100644
--- a/render-wasm/src/render/text.rs
+++ b/render-wasm/src/render/text.rs
@@ -16,6 +16,7 @@ use skia_safe::{
     textlayout::{ParagraphBuilder, RectHeightStyle, RectWidthStyle, StyleMetrics, TextDecoration},
     Canvas, ImageFilter, Paint,
 };
+use std::borrow::Cow;
 use text_vertical::GlyphOutput;
 
 /// Vertical text: shadows, fill, strokes and the debug grid, all painted from
@@ -169,17 +170,50 @@ pub fn stroke_paragraph_builder_group_from_text(
     let mut group_layer_opacity: Option<f32> = None;
 
     let plans = text_content.horizontal_plans();
-    for (paragraph, plan) in text_content.paragraphs().iter().zip(plans.iter()) {
+    let adjustments = plans
+        .iter()
+        .any(|plan| plan.has_atomic_overflow())
+        .then(|| text_content.horizontal_line_adjustments())
+        .flatten();
+    for (index, (paragraph, plan)) in text_content
+        .paragraphs()
+        .iter()
+        .zip(plans.iter())
+        .enumerate()
+    {
+        let adjustment = plan
+            .has_atomic_overflow()
+            .then(|| {
+                adjustments
+                    .as_ref()
+                    .and_then(|adjustments| adjustments[index].as_ref())
+            })
+            .flatten();
         let mut stroke_paragraphs_map: std::collections::HashMap<usize, ParagraphBuilder> =
             std::collections::HashMap::new();
 
-        for (((span, text), sheds), extra) in paragraph
+        for (span_index, (((span, text), sheds), extra)) in paragraph
             .children()
             .iter()
             .zip(&plan.texts)
             .zip(&plan.sheds)
             .zip(&plan.ruby_spacing.adjustments)
+            .enumerate()
         {
+            let sheds: Cow<'_, [(usize, f32)]> = adjustment
+                .map_or(Cow::Borrowed(sheds.as_slice()), |a| {
+                    Cow::Owned(sheds.iter().chain(&a.sheds[span_index]).copied().collect())
+                });
+            let extra: Cow<'_, [(usize, f32)]> =
+                adjustment.map_or(Cow::Borrowed(extra.as_slice()), |a| {
+                    Cow::Owned(
+                        extra
+                            .iter()
+                            .chain(&a.spacing[span_index])
+                            .copied()
+                            .collect(),
+                    )
+                });
             let (stroke_paints, stroke_layer_opacity) =
                 get_text_stroke_paints(stroke, bounds, remove_stroke_alpha);
 
@@ -189,7 +223,13 @@ pub fn stroke_paragraph_builder_group_from_text(
 
             for (paint_idx, stroke_paint) in stroke_paints.iter().enumerate() {
                 let builder = stroke_paragraphs_map.entry(paint_idx).or_insert_with(|| {
-                    let paragraph_style = paragraph.paragraph_to_style();
+                    let mut paragraph_style = paragraph.paragraph_to_style();
+                    if plan.has_atomic_overflow() {
+                        paragraph_style.set_apply_rounding_hack(false);
+                        if paragraph.text_align() == skia::textlayout::TextAlign::Justify {
+                            paragraph_style.set_text_align(skia::textlayout::TextAlign::Left);
+                        }
+                    }
                     ParagraphBuilder::new(&paragraph_style, fonts)
                 });
                 let stroke_paint = stroke_paint.clone();
@@ -201,7 +241,7 @@ pub fn stroke_paragraph_builder_group_from_text(
                     paragraph.line_height(),
                 );
                 builder.push_style(&stroke_style);
-                add_horizontal_span(builder, span, text, sheds, extra, &stroke_style, fonts);
+                add_horizontal_span(builder, span, text, &sheds, &extra, &stroke_style, fonts);
             }
         }
 
@@ -571,6 +611,10 @@ fn paint_from_cached_layout(canvas: &Canvas, shape: &Shape, text_content: &TextC
         let Some(paragraph) = group.first() else {
             continue;
         };
+        let x = x + plans
+            .get(index)
+            .zip(text_content.paragraphs().get(index))
+            .map_or(0.0, |(plan, model)| plan.x_offset(model, selrect.width()));
         paragraph.paint(canvas, (x, y_accum));
         if let (Some(text_paragraph), Some(plan)) =
             (text_content.paragraphs().get(index), plans.get(index))
diff --git a/render-wasm/src/render/text_editor.rs b/render-wasm/src/render/text_editor.rs
index af78d6f375..373b55de67 100644
--- a/render-wasm/src/render/text_editor.rs
+++ b/render-wasm/src/render/text_editor.rs
@@ -243,18 +243,37 @@ pub(crate) fn cursor_rect(
             .iter()
             .map(|paragraph| paragraph.height())
             .sum::<f32>();
-    let rect = horizontal_caret_rect(&paragraphs[cursor.paragraph], laid_out_para, cursor.offset);
-    Some(rect.with_offset((0.0, y_offset)))
+    let plans = text_content.horizontal_plans();
+    let plan = plans.get(cursor.paragraph)?;
+    let model = &paragraphs[cursor.paragraph];
+    let rect =
+        horizontal_caret_rect_with_offsets(model, laid_out_para, cursor.offset, &plan.offsets);
+    Some(rect.with_offset((plan.x_offset(model, shape.selrect.width()), y_offset)))
 }
 
 /// Caret rect at the source character offset `char_pos` of a laid-out
 /// horizontal paragraph, in the paragraph's coordinates. It covers the
 /// character at the offset (overtype carets use its width), or follows the
 /// last character at the paragraph end.
+#[cfg(test)]
 fn horizontal_caret_rect(
     para: &crate::shapes::Paragraph,
     laid_out_para: &skia_safe::textlayout::Paragraph,
     char_pos: usize,
+) -> Rect {
+    horizontal_caret_rect_with_offsets(
+        para,
+        laid_out_para,
+        char_pos,
+        &crate::shapes::HorizontalOffsets::new(para),
+    )
+}
+
+fn horizontal_caret_rect_with_offsets(
+    para: &crate::shapes::Paragraph,
+    laid_out_para: &skia_safe::textlayout::Paragraph,
+    char_pos: usize,
+    offsets: &crate::shapes::HorizontalOffsets,
 ) -> Rect {
     if let Some(rect) = crate::shapes::horizontal_warichu_caret_rect(para, laid_out_para, char_pos)
     {
@@ -272,7 +291,6 @@ fn horizontal_caret_rect(
 
     // Cursor offsets count source characters; the laid-out paragraph indexes
     // the transformed, kinsoku-shifted builder text.
-    let offsets = crate::shapes::HorizontalOffsets::new(para);
     let first_rect = |start: usize, end: usize| {
         laid_out_para
             .get_rects_for_range(start..end, RectHeightStyle::Max, RectWidthStyle::Tight)
@@ -351,6 +369,7 @@ fn range_rects(
     let mut rects = Vec::new();
     let (start_paragraph, start_offset) = start;
     let (end_paragraph, end_offset) = end;
+    let plans = text_content.horizontal_plans();
 
     let paragraphs = text_content.paragraphs();
     let layout_paragraphs: Vec<_> = text_content.layout.paragraphs.iter().flatten().collect();
@@ -368,6 +387,8 @@ fn range_rects(
 
         // Calculate character range for this paragraph
         let para = &paragraphs[para_idx];
+        let plan = &plans[para_idx];
+        let x_offset = plan.x_offset(para, shape.selrect.width());
         let para_char_count: usize = para
             .children()
             .iter()
@@ -397,14 +418,15 @@ fn range_rects(
             );
             for r in warichu_rects {
                 rects.push(Rect::from_xywh(
-                    r.left(),
+                    r.left() + x_offset,
                     y_offset + r.top(),
                     r.width(),
                     r.height(),
                 ));
             }
             use skia_safe::textlayout::{RectHeightStyle, RectWidthStyle};
-            for builder_range in crate::shapes::HorizontalOffsets::new(para)
+            for builder_range in plan
+                .offsets
                 .normal_selection_ranges(para, range_start, range_end)
             {
                 for text_box in laid_out_para.get_rects_for_range(
@@ -414,7 +436,7 @@ fn range_rects(
                 ) {
                     let r = text_box.rect;
                     rects.push(Rect::from_xywh(
-                        r.left(),
+                        r.left() + x_offset,
                         y_offset + r.top(),
                         r.width(),
                         r.height(),
@@ -587,4 +609,235 @@ mod tests {
         let caret = horizontal_caret_rect(&paragraph(""), &laid_out, 0);
         assert_eq!(caret, Rect::from_xywh(0.0, 0.0, 1.0, laid_out.height()));
     }
+    #[test]
+    fn narrow_cjk_layout_shares_alignment_with_carets_selection_hit_testing_and_exports() {
+        use crate::shapes::calculate_text_layout_data;
+        use crate::shapes::text_paths::TextPaths;
+        use crate::shapes::text_vertical::test_support::provider;
+        use crate::shapes::{GrowType, TextPositionWithAffinity, VerticalAlign};
+        crate::globals::design_init();
+        let mut resources =
+            crate::render::RenderResources::try_new_headless().expect("headless resources");
+        let mut fonts = resources.fonts.font_collection().clone();
+        fonts.set_asset_font_manager(Some(
+            provider(include_bytes!("../fonts/cjk-locl-test.ttf")).into(),
+        ));
+        let _guard = crate::globals::TestRenderResourcesGuard::install(&mut resources);
+        for align in [
+            TextAlign::Left,
+            TextAlign::Right,
+            TextAlign::Center,
+            TextAlign::Justify,
+        ] {
+            for grow in [GrowType::Fixed, GrowType::AutoHeight] {
+                let spans = ["文文", "文", "。", "文文"]
+                    .iter()
+                    .map(|text| TextSpan {
+                        text: text.to_string(),
+                        font_size: 20.0,
+                        line_height: 1.0,
+                        ..TextSpan::default()
+                    })
+                    .collect();
+                let mut model =
+                    Paragraph::new(align, TextDirection::LTR, None, None, 1.0, 0.0, spans);
+                model.set_language("zh-Hant-TW".to_owned());
+                let mut content =
+                    TextContent::new(crate::math::Rect::from_xywh(0.0, 0.0, 20.0, 300.0), grow);
+                content.add_paragraph(model.clone());
+                content.add_paragraph(model);
+                let mut shape = Shape::new(crate::Uuid::nil());
+                shape.set_selrect(0.0, 0.0, 20.0, 300.0);
+                content.update_layout(shape.selrect);
+                let plans = content.horizontal_plans();
+                let mut editor = TextEditorState::new();
+                let data = calculate_text_layout_data(
+                    &shape,
+                    &content,
+                    &mut content.paragraph_builder_group_from_text(None),
+                    false,
+                );
+                let mut paragraph_y = 0.0;
+                for paragraph_index in 0..2 {
+                    let laid_out = &content.layout.paragraphs[paragraph_index][0];
+                    let plan = &plans[paragraph_index];
+                    let x_offset = plan.x_offset(&content.paragraphs()[paragraph_index], 20.0);
+                    let lines = laid_out.get_line_metrics();
+                    assert_eq!(lines.len(), 5, "{align:?} {grow:?}");
+                    let atomic_left = lines[2].left as f32 + x_offset;
+                    let expected_left = match align {
+                        TextAlign::Right => -20.0,
+                        TextAlign::Center => -10.0,
+                        _ => 0.0,
+                    };
+                    assert!(
+                        (atomic_left - expected_left).abs() < 0.02,
+                        "{align:?}: {atomic_left}"
+                    );
+                    assert!(
+                        (lines[0].left as f32 + x_offset).abs() < 0.02,
+                        "ordinary text stays within its box"
+                    );
+                    for (offset, line_index) in [0, 1, 2, 2, 3, 4].into_iter().enumerate() {
+                        let position = TextPositionWithAffinity::new_downstream_affinity(
+                            paragraph_index,
+                            offset,
+                        );
+                        editor.selection.set_caret(position);
+                        let caret = cursor_rect(&editor, &content, &shape).expect("caret");
+                        let line_top = paragraph_y
+                            + lines[..line_index]
+                                .iter()
+                                .map(|line| line.height as f32)
+                                .sum::<f32>();
+                        assert!(
+                            (caret.top() - line_top).abs() < 0.1,
+                            "caret {offset} in {align:?}: {caret:?}"
+                        );
+                        let hit = content
+                            .get_caret_position_from_shape_coords(
+                                &crate::math::Point::new(
+                                    caret.left() + caret.width() * 0.1,
+                                    caret.center_y(),
+                                ),
+                                &shape.selrect,
+                                VerticalAlign::Top,
+                            )
+                            .expect("hit");
+                        assert_eq!(
+                            (hit.paragraph, hit.offset),
+                            (paragraph_index, offset),
+                            "{align:?}, caret={caret:?}"
+                        );
+                    }
+                    editor.selection.anchor =
+                        TextPositionWithAffinity::new_downstream_affinity(paragraph_index, 2);
+                    editor.selection.focus =
+                        TextPositionWithAffinity::new_downstream_affinity(paragraph_index, 4);
+                    let selected = calculate_selection_rects(&editor.selection, &content, &shape);
+                    assert!(!selected.is_empty());
+                    assert!(selected.iter().all(|rect| (rect.top()
+                        - paragraph_y
+                        - lines[..2]
+                            .iter()
+                            .map(|line| line.height as f32)
+                            .sum::<f32>())
+                    .abs()
+                        < 0.1));
+                    assert!((selected.iter().map(|r| r.width()).sum::<f32>() - 40.0).abs() < 0.1);
+                    let exported = &data.paragraphs[paragraph_index];
+                    assert!((exported.x - x_offset).abs() < 0.01);
+                    assert!((exported.y - paragraph_y).abs() < 0.01);
+                    assert_eq!(exported.paragraph.get_line_metrics().len(), 5);
+                    paragraph_y += laid_out.height();
+                }
+                let paths = TextPaths::new(content.clone()).get_paths(VerticalAlign::Top);
+                assert!(!paths.is_empty());
+                let mut bounds = skia_safe::Rect::new_empty();
+                for path in paths {
+                    bounds.join(path.bounds());
+                }
+                assert!(
+                    bounds.height() > paragraph_y - 30.0,
+                    "paths include both paragraphs"
+                );
+                assert!(
+                    bounds.width() > 20.0,
+                    "paths include the overflowing punctuation unit: {align:?} {bounds:?}"
+                );
+                assert!(
+                    content.get_height(160.0) < paragraph_y / 2.0,
+                    "prospective width uses a fresh plan"
+                );
+                let before: Vec<_> = plans.iter().map(|plan| plan.texts.clone()).collect();
+                content.update_layout(crate::math::Rect::from_xywh(0.0, 0.0, 160.0, 300.0));
+                assert!(content
+                    .layout
+                    .paragraphs
+                    .iter()
+                    .all(|group| group[0].get_line_metrics().len() == 1));
+                assert!(content.horizontal_plans().iter().all(|plan| !plan
+                    .texts
+                    .concat()
+                    .contains(crate::shapes::kinsoku::FORCED_LINE_BREAK)));
+                content.update_layout(shape.selrect);
+                assert_eq!(
+                    content
+                        .horizontal_plans()
+                        .iter()
+                        .map(|plan| plan.texts.clone())
+                        .collect::<Vec<_>>(),
+                    before,
+                    "narrow/wide/narrow restores the plan"
+                );
+                assert_eq!(
+                    content.paragraphs()[0]
+                        .children()
+                        .iter()
+                        .map(|s| s.text.as_str())
+                        .collect::<String>(),
+                    "文文文。文文"
+                );
+            }
+        }
+    }
+    #[test]
+    fn narrow_cjk_fractional_strokes_share_the_fill_breaks_and_advances() {
+        use crate::shapes::text_vertical::test_support::provider;
+        use crate::shapes::{GrowType, Stroke, StrokeStyle};
+        crate::globals::design_init();
+        let mut resources =
+            crate::render::RenderResources::try_new_headless().expect("headless resources");
+        let mut fonts = resources.fonts.font_collection().clone();
+        fonts.set_asset_font_manager(Some(
+            provider(include_bytes!("../fonts/cjk-locl-test.ttf")).into(),
+        ));
+        let _guard = crate::globals::TestRenderResourcesGuard::install(&mut resources);
+        let spans = ["文文", "文", "。", "文文"]
+            .iter()
+            .map(|text| TextSpan {
+                text: text.to_string(),
+                font_size: 20.125,
+                line_height: 1.0,
+                ..TextSpan::default()
+            })
+            .collect();
+        let mut model = Paragraph::new(
+            TextAlign::Justify,
+            TextDirection::LTR,
+            None,
+            None,
+            1.0,
+            0.0,
+            spans,
+        );
+        model.set_language("zh-Hant-TW".to_owned());
+        let mut content = TextContent::new(
+            crate::math::Rect::from_xywh(0.0, 0.0, 32.25, 300.0),
+            GrowType::Fixed,
+        );
+        content.add_paragraph(model);
+        content.update_layout(content.bounds());
+        let stroke = Stroke::new_center_stroke(1.0, StrokeStyle::Solid, None, None, None, None);
+        let (mut builders, _) = crate::render::text::stroke_paragraph_builder_group_from_text(
+            &content,
+            &stroke,
+            &content.bounds(),
+            None,
+        );
+        assert!(!builders[0].is_empty());
+        let mut stroked = builders[0][0].build();
+        stroked.layout(content.horizontal_plans()[0].layout_width(32.25));
+        let fill_lines = content.layout.paragraphs[0][0].get_line_metrics();
+        let stroke_lines = stroked.get_line_metrics();
+        assert_eq!(fill_lines.len(), stroke_lines.len());
+        for (fill, stroke) in fill_lines.iter().zip(&stroke_lines) {
+            assert_eq!(
+                (fill.start_index, fill.end_index),
+                (stroke.start_index, stroke.end_index)
+            );
+            assert!((fill.width - stroke.width).abs() < 0.01);
+            assert!((fill.left - stroke.left).abs() < 0.01);
+        }
+    }
 }
diff --git a/render-wasm/src/shapes/kinsoku.rs b/render-wasm/src/shapes/kinsoku.rs
index 18251bfdb4..6dc34d74eb 100644
--- a/render-wasm/src/shapes/kinsoku.rs
+++ b/render-wasm/src/shapes/kinsoku.rs
@@ -18,11 +18,14 @@ pub const WORD_JOINER: char = '\u{2060}';
 /// ZERO WIDTH SPACE: opens a break UAX #14 forbids but JLREQ allows, before
 /// an inseparable mark such as … (JLREQ only keeps two of them together).
 pub const BREAK_OPPORTUNITY: char = '\u{200B}';
+/// Layout-only line separator used to retain the original wrap budget when
+/// an indivisible CJK unit needs more width than its container.
+pub const FORCED_LINE_BREAK: char = '\u{2028}';
 
 /// True for the zero-width characters this pass inserts to steer breaks;
 /// they take no letter-spacing and count as no character.
 pub fn is_inserted_zero_width(ch: char) -> bool {
-    ch == WORD_JOINER || ch == BREAK_OPPORTUNITY
+    ch == WORD_JOINER || ch == BREAK_OPPORTUNITY || ch == FORCED_LINE_BREAK
 }
 /// Unicode FOUR-PER-EM SPACE, used for the preferred Japanese/Western gap.
 pub const JAPANESE_WESTERN_SPACE: char = '\u{2005}';
@@ -104,19 +107,21 @@ fn apply_to_span_texts_with_ruby_breaks(
     apply_policy_to_span_texts(span_texts, ruby_breaks, TextLayoutPolicy::Japanese)
 }
 
+#[cfg(test)]
 pub fn apply_policy_to_span_texts(
     span_texts: &[String],
     ruby_breaks: &[Option<Vec<usize>>],
     policy: TextLayoutPolicy,
 ) -> Option<(Vec<String>, OffsetMap)> {
-    apply_policy_with_emergency_breaks(span_texts, ruby_breaks, policy, &[])
+    apply_policy_with_breaks(span_texts, ruby_breaks, policy, &[], &[])
 }
 
-pub fn apply_policy_with_emergency_breaks(
+pub fn apply_policy_with_breaks(
     span_texts: &[String],
     ruby_breaks: &[Option<Vec<usize>>],
     policy: TextLayoutPolicy,
     emergency_breaks: &[usize],
+    forced_breaks: &[usize],
 ) -> Option<(Vec<String>, OffsetMap)> {
     let source = span_texts.concat();
     let boundaries: Vec<usize> = source.grapheme_indices(true).map(|(at, _)| at).collect();
@@ -176,7 +181,9 @@ pub fn apply_policy_with_emergency_breaks(
                 insert(JAPANESE_WESTERN_SPACE);
             }
             // After an inserted space, the joiner keeps the break blocked.
-            if forbid_break {
+            if forced_breaks.binary_search(&source_at).is_ok() {
+                insert(FORCED_LINE_BREAK);
+            } else if forbid_break {
                 insert(if emergency_breaks.binary_search(&source_at).is_ok() {
                     BREAK_OPPORTUNITY
                 } else {
diff --git a/render-wasm/src/shapes/text.rs b/render-wasm/src/shapes/text.rs
index 4c66b0f6b1..ea3f62f502 100644
--- a/render-wasm/src/shapes/text.rs
+++ b/render-wasm/src/shapes/text.rs
@@ -31,7 +31,9 @@ use super::text_japanese::*;
 use super::{FontFamily, FontStyle};
 use crate::math::Point;
 use crate::render::FallbackFonts;
-use crate::shapes::{self, kinsoku, merge_fills, Shape, Type, VerticalAlign};
+#[cfg(test)]
+use crate::shapes::kinsoku;
+use crate::shapes::{self, merge_fills, Shape, Type, VerticalAlign};
 use crate::utils::{get_fallback_fonts, get_font_collection};
 use crate::Uuid;
 
@@ -287,8 +289,8 @@ struct HorizontalPlansCache {
 /// justifies them.
 #[derive(Debug, Clone, Default)]
 pub(crate) struct HorizontalAdjustment {
-    sheds: Vec<Vec<(usize, f32)>>,
-    spacing: Vec<Vec<(usize, f32)>>,
+    pub(crate) sheds: Vec<Vec<(usize, f32)>>,
+    pub(crate) spacing: Vec<Vec<(usize, f32)>>,
 }
 
 /// Per paragraph; `None` for paragraphs laid out by Skia alone.
@@ -428,34 +430,40 @@ fn intersects(paragraph: &skia_safe::textlayout::Paragraph, x: f32, y: f32) -> b
 }
 
 fn paragraph_intersects<'a>(
-    paragraphs: impl Iterator<Item = &'a skia::textlayout::Paragraph>,
+    paragraphs: impl Iterator<Item = (&'a skia::textlayout::Paragraph, f32)>,
     x_pos: f32,
     y_pos: f32,
 ) -> bool {
     paragraphs
-        .scan(0.0_f32, |height, p| {
+        .scan(0.0_f32, |height, (p, x_offset)| {
             let prev_height = *height;
             *height += p.height();
-            Some((prev_height, p))
+            Some((prev_height, p, x_offset))
         })
-        .any(|(height, p)| intersects(p, x_pos, y_pos - height))
+        .any(|(height, p, x_offset)| intersects(p, x_pos - x_offset, y_pos - height))
 }
 
 // Performs a text auto layout without width limits.
 // This should be the same as text_auto_layout.
-pub fn build_paragraphs_from_paragraph_builders(
+pub(crate) fn build_paragraphs_from_paragraph_builders(
     paragraph_builders: &mut [ParagraphBuilderGroup],
     width: f32,
+    plans: &[HorizontalParagraphPlan],
 ) -> Vec<Vec<skia::textlayout::Paragraph>> {
     let paragraphs = paragraph_builders
         .iter_mut()
-        .map(|builders| {
+        .enumerate()
+        .map(|(index, builders)| {
             builders
                 .iter_mut()
                 .map(|builder| {
                     let mut paragraph = builder.build();
                     // For auto-width, always layout with infinite width first to get intrinsic width
-                    paragraph.layout(width);
+                    paragraph.layout(
+                        plans
+                            .get(index)
+                            .map_or(width, |plan| plan.layout_width(width)),
+                    );
                     paragraph
                 })
                 .collect()
@@ -465,15 +473,20 @@ pub fn build_paragraphs_from_paragraph_builders(
 }
 
 /// Calculate the normalized line height from paragraph builders
-pub fn calculate_normalized_line_height(
+pub(crate) fn calculate_normalized_line_height(
     paragraph_builders: &mut [ParagraphBuilderGroup],
     width: f32,
+    plans: &[HorizontalParagraphPlan],
 ) -> f32 {
     let mut normalized_line_height = 0.0;
-    for paragraph_builder_group in paragraph_builders.iter_mut() {
+    for (index, paragraph_builder_group) in paragraph_builders.iter_mut().enumerate() {
         for paragraph_builder in paragraph_builder_group.iter_mut() {
             let mut paragraph = paragraph_builder.build();
-            paragraph.layout(width);
+            paragraph.layout(
+                plans
+                    .get(index)
+                    .map_or(width, |plan| plan.layout_width(width)),
+            );
             let baseline = paragraph.ideographic_baseline();
             if baseline > normalized_line_height {
                 normalized_line_height = baseline;
@@ -683,7 +696,7 @@ impl TextContent {
     /// Squeeze sheds and justify spacing of each horizontal paragraph at
     /// the layout width, cached until the content or the width
     /// changes. `None` when no paragraph needs them.
-    fn horizontal_line_adjustments(&self) -> Option<HorizontalAdjustments> {
+    pub(crate) fn horizontal_line_adjustments(&self) -> Option<HorizontalAdjustments> {
         if self.is_vertical() || self.grow_type() == GrowType::AutoWidth {
             return None;
         }
@@ -731,7 +744,7 @@ impl TextContent {
             let mut laid_out = self
                 .horizontal_measure_builder(paragraph, plan, extra_sheds)
                 .build();
-            laid_out.layout(width);
+            laid_out.layout(plan.layout_width(width));
             laid_out
         };
         let (sheds, laid_out) = if paragraph.layout_policy()
@@ -807,7 +820,11 @@ impl TextContent {
     /// sheds, ruby spacing), cached until content or width changes; clones
     /// share them. A font load bumps the content version for shaped spacing.
     pub(crate) fn horizontal_plans(&self) -> Rc<Vec<HorizontalParagraphPlan>> {
-        let width = self.get_width(self.bounds().width());
+        let width = if self.grow_type() == GrowType::AutoWidth {
+            f32::MAX
+        } else {
+            self.bounds().width()
+        };
         if let Some(entry) = self.layout.horizontal.borrow().as_ref() {
             if entry.version == self.content_version && entry.width == width {
                 return Rc::clone(&entry.plans);
@@ -826,6 +843,14 @@ impl TextContent {
                         measured.layout(width);
                         measured
                     });
+                    plan.retain_atomic_overflow(paragraph, width, |plan, width| {
+                        let sheds = vec![Vec::new(); plan.texts.len()];
+                        let mut measured = self
+                            .horizontal_measure_builder(paragraph, plan, &sheds)
+                            .build();
+                        measured.layout(width);
+                        measured
+                    });
                     plan
                 })
                 .collect(),
@@ -897,8 +922,10 @@ impl TextContent {
         let mut has_lines = false;
         let mut y_accum = base_y + vertical_offset;
 
-        for group in paragraphs.iter() {
+        let plans = self.horizontal_plans();
+        for (index, group) in paragraphs.iter().enumerate() {
             if let Some(paragraph) = group.first() {
+                let x = x + plans[index].x_offset(&self.paragraphs[index], selrect.width());
                 let line_metrics = paragraph.get_line_metrics();
                 for line in &line_metrics {
                     let line_baseline = y_accum + line.baseline as f32;
@@ -1136,7 +1163,12 @@ impl TextContent {
                 // Skia's get_glyph_position_at_coordinate expects coordinates relative to
                 // the paragraph's top-left. For multi-paragraph or wrapped text, each
                 // paragraph has its own origin; subtract start_y so we pass paragraph-local coords.
-                let para_pt = Point::new(point.x, point.y - start_y);
+                let plans = self.horizontal_plans();
+                let x_offset = plans
+                    .get(paragraph_index)
+                    .zip(self.paragraphs().get(paragraph_index))
+                    .map_or(0.0, |(plan, model)| plan.x_offset(model, selrect.width()));
+                let para_pt = Point::new(point.x - x_offset, point.y - start_y);
                 if let Some(paragraph) = self.paragraphs().get(paragraph_index) {
                     if let Some(original_position) =
                         horizontal_warichu_hit_test(paragraph, layout_paragraph, para_pt)
@@ -1294,7 +1326,7 @@ impl TextContent {
                 .and_then(|adjustments| adjustments.get(paragraph_index))
                 .and_then(Option::as_ref);
             let mut paragraph_style = paragraph.paragraph_to_style();
-            if self.adjusts_lines(paragraph, plan) {
+            if self.adjusts_lines(paragraph, plan) || plan.has_atomic_overflow() {
                 // Line adjustment gives characters runs of their own; rounding
                 // each run up would wrap the adjusted lines. The measuring
                 // pass shares this style so both break alike.
@@ -1420,11 +1452,17 @@ impl TextContent {
             None,
         );
 
-        let normalized_line_height =
-            calculate_normalized_line_height(&mut measure_builders, f32::MAX);
+        let normalized_line_height = calculate_normalized_line_height(
+            &mut measure_builders,
+            f32::MAX,
+            &self.horizontal_plans(),
+        );
 
-        let measure_paragraphs =
-            build_paragraphs_from_paragraph_builders(&mut measure_builders, f32::MAX);
+        let measure_paragraphs = build_paragraphs_from_paragraph_builders(
+            &mut measure_builders,
+            f32::MAX,
+            &self.horizontal_plans(),
+        );
 
         let content_width = measure_paragraphs
             .iter()
@@ -1436,8 +1474,11 @@ impl TextContent {
 
         // Re-layout at the intrinsic width (without the HTML margin slack).
         let mut paragraph_builders = self.paragraph_builder_group_from_text(None);
-        let paragraphs =
-            build_paragraphs_from_paragraph_builders(&mut paragraph_builders, content_width);
+        let paragraphs = build_paragraphs_from_paragraph_builders(
+            &mut paragraph_builders,
+            content_width,
+            &self.horizontal_plans(),
+        );
         let height = paragraphs
             .iter()
             .flatten()
@@ -1461,10 +1502,17 @@ impl TextContent {
         let width = self.width();
         let mut paragraph_builders = self.paragraph_builder_group_from_text(None);
 
-        let normalized_line_height =
-            calculate_normalized_line_height(&mut paragraph_builders, width);
+        let normalized_line_height = calculate_normalized_line_height(
+            &mut paragraph_builders,
+            width,
+            &self.horizontal_plans(),
+        );
 
-        let paragraphs = build_paragraphs_from_paragraph_builders(&mut paragraph_builders, width);
+        let paragraphs = build_paragraphs_from_paragraph_builders(
+            &mut paragraph_builders,
+            width,
+            &self.horizontal_plans(),
+        );
         let height = paragraphs
             .iter()
             .flatten()
@@ -1485,10 +1533,17 @@ impl TextContent {
         let width = self.width();
         let mut paragraph_builders = self.paragraph_builder_group_from_text(None);
 
-        let normalized_line_height =
-            calculate_normalized_line_height(&mut paragraph_builders, width);
+        let normalized_line_height = calculate_normalized_line_height(
+            &mut paragraph_builders,
+            width,
+            &self.horizontal_plans(),
+        );
 
-        let paragraphs = build_paragraphs_from_paragraph_builders(&mut paragraph_builders, width);
+        let paragraphs = build_paragraphs_from_paragraph_builders(
+            &mut paragraph_builders,
+            width,
+            &self.horizontal_plans(),
+        );
         let paragraph_height = paragraphs
             .iter()
             .flatten()
@@ -1514,8 +1569,21 @@ impl TextContent {
     }
 
     pub fn get_height(&self, width: f32) -> f32 {
-        let mut paragraph_builders = self.paragraph_builder_group_from_text(None);
-        let paragraphs = build_paragraphs_from_paragraph_builders(&mut paragraph_builders, width);
+        // A prospective width needs its own plan: frozen overflow breaks
+        // from the current bounds must not determine a resized box's height.
+        let mut content = self.clone();
+        content.set_xywh(
+            self.bounds.x(),
+            self.bounds.y(),
+            width,
+            self.bounds.height(),
+        );
+        let mut paragraph_builders = content.paragraph_builder_group_from_text(None);
+        let paragraphs = build_paragraphs_from_paragraph_builders(
+            &mut paragraph_builders,
+            width,
+            &content.horizontal_plans(),
+        );
         let paragraph_height = paragraphs
             .iter()
             .flatten()
@@ -1832,13 +1900,22 @@ impl TextContent {
         let x_pos = result.x - rect.x();
         let y_pos = result.y - rect.y();
 
+        let plans = self.horizontal_plans();
         if !self.layout.paragraphs.is_empty() {
             // Reuse stored laid-out paragraphs
             paragraph_intersects(
                 self.layout
                     .paragraphs
                     .iter()
-                    .flat_map(|group| group.first()),
+                    .enumerate()
+                    .filter_map(|(index, group)| {
+                        group.first().map(|paragraph| {
+                            (
+                                paragraph,
+                                plans[index].x_offset(&self.paragraphs[index], rect.width()),
+                            )
+                        })
+                    }),
                 x_pos,
                 y_pos,
             )
@@ -1846,9 +1923,20 @@ impl TextContent {
             let width = self.width();
             let mut paragraph_builders = self.paragraph_builder_group_from_text(None);
             let paragraphs =
-                build_paragraphs_from_paragraph_builders(&mut paragraph_builders, width);
+                build_paragraphs_from_paragraph_builders(&mut paragraph_builders, width, &plans);
 
-            paragraph_intersects(paragraphs.iter().flatten(), x_pos, y_pos)
+            paragraph_intersects(
+                paragraphs.iter().enumerate().filter_map(|(index, group)| {
+                    group.first().map(|paragraph| {
+                        (
+                            paragraph,
+                            plans[index].x_offset(&self.paragraphs[index], width),
+                        )
+                    })
+                }),
+                x_pos,
+                y_pos,
+            )
         }
     }
 }
@@ -2124,6 +2212,7 @@ impl Paragraph {
     /// plus the map from original to builder-text UTF-16 offsets. Consumers
     /// of laid-out offsets must translate through the map. Only paragraphs
     /// with an explicit typography profile are transformed.
+    #[cfg(test)]
     pub fn layout_span_texts(&self) -> (Vec<String>, kinsoku::OffsetMap) {
         layout_span_texts(self)
     }
@@ -2710,13 +2799,13 @@ pub fn calculate_text_layout_data(
     let mut paragraph_heights: Vec<f32> = Vec::new();
     let mut built_groups: Vec<Vec<skia::textlayout::Paragraph>> =
         Vec::with_capacity(paragraph_builder_groups.len());
-    for paragraph_builder_group in paragraph_builder_groups.iter_mut() {
+    for (index, paragraph_builder_group) in paragraph_builder_groups.iter_mut().enumerate() {
         let group_len = paragraph_builder_group.len();
         let mut paragraph_offset_y = previous_line_height;
         let mut group_paragraphs: Vec<skia::textlayout::Paragraph> = Vec::with_capacity(group_len);
         for (builder_index, paragraph_builder) in paragraph_builder_group.iter_mut().enumerate() {
             let mut skia_paragraph = paragraph_builder.build();
-            skia_paragraph.layout(text_width);
+            skia_paragraph.layout(plans[index].layout_width(text_width));
             if builder_index == group_len - 1 {
                 if skia_paragraph.get_line_metrics().is_empty() {
                     paragraph_offset_y = skia_paragraph.ideographic_baseline();
@@ -2742,6 +2831,7 @@ pub fn calculate_text_layout_data(
     for (i, group_paragraphs) in built_groups.into_iter().enumerate() {
         // For each paragraph in the group (e.g., fill, stroke, etc.)
         for skia_paragraph in group_paragraphs.into_iter() {
+            let x = x + plans[i].x_offset(&text_paragraphs[i], text_width);
             let decorations = text_paragraphs
                 .get(i)
                 .zip(plans.get(i))
diff --git a/render-wasm/src/shapes/text_horizontal/mod.rs b/render-wasm/src/shapes/text_horizontal/mod.rs
index 5a23cb647e..057a342d50 100644
--- a/render-wasm/src/shapes/text_horizontal/mod.rs
+++ b/render-wasm/src/shapes/text_horizontal/mod.rs
@@ -5,6 +5,7 @@
 mod emphasis;
 mod justify;
 mod offsets;
+mod overflow;
 mod ruby;
 mod warichu;
 
@@ -49,13 +50,15 @@ pub(crate) fn uses_japanese_layout(paragraph: &Paragraph, texts: &[String]) -> b
                 .any(|text| text.chars().any(is_japanese_text_char)))
 }
 
+#[cfg(test)]
 pub(crate) fn layout_span_texts(paragraph: &Paragraph) -> (Vec<String>, kinsoku::OffsetMap) {
-    layout_span_texts_with_emergency(paragraph, &[])
+    layout_span_texts_with_breaks(paragraph, &[], &[])
 }
 
-fn layout_span_texts_with_emergency(
+fn layout_span_texts_with_breaks(
     paragraph: &Paragraph,
     emergency: &[usize],
+    forced: &[usize],
 ) -> (Vec<String>, kinsoku::OffsetMap) {
     let texts: Vec<String> = paragraph
         .children()
@@ -70,11 +73,8 @@ fn layout_span_texts_with_emergency(
             .iter()
             .map(|span| span.has_ruby().then(Vec::new))
             .collect();
-        let shifted = if emergency.is_empty() {
-            kinsoku::apply_policy_to_span_texts(&texts, &ruby_breaks, policy)
-        } else {
-            kinsoku::apply_policy_with_emergency_breaks(&texts, &ruby_breaks, policy, emergency)
-        };
+        let shifted =
+            kinsoku::apply_policy_with_breaks(&texts, &ruby_breaks, policy, emergency, forced);
         if let Some((shifted, map)) = shifted {
             return (shifted, map);
         }
@@ -172,6 +172,9 @@ pub(crate) fn add_horizontal_span(
     fonts: &skia::textlayout::FontCollection,
 ) {
     if span.is_warichu() {
+        if builder_text.starts_with(kinsoku::FORCED_LINE_BREAK) {
+            builder.add_text(kinsoku::FORCED_LINE_BREAK.to_string());
+        }
         let text = span.apply_text_transform();
         let (first, second) = warichu_text_lines(&text);
         let mut mini_style = text_style.clone();
@@ -263,6 +266,8 @@ pub(crate) struct HorizontalParagraphPlan {
     pub(crate) offsets: HorizontalOffsets,
     pub(crate) sheds: Vec<Vec<(usize, f32)>>,
     pub(crate) ruby_spacing: HorizontalRubySpacing,
+    emergency_breaks: Vec<usize>,
+    overflow_width: Option<f32>,
 }
 
 impl HorizontalParagraphPlan {
@@ -377,7 +382,11 @@ impl HorizontalParagraphPlan {
     }
 
     fn with_emergency_breaks(paragraph: &Paragraph, emergency: &[usize]) -> Self {
-        let (texts, offset_map) = layout_span_texts_with_emergency(paragraph, emergency);
+        Self::with_breaks(paragraph, emergency, &[])
+    }
+
+    fn with_breaks(paragraph: &Paragraph, emergency: &[usize], forced: &[usize]) -> Self {
+        let (texts, offset_map) = layout_span_texts_with_breaks(paragraph, emergency, forced);
         let sheds = horizontal_aki_sheds(paragraph, &texts);
         let ruby_spacing = horizontal_ruby_spacing(paragraph, &texts, &offset_map);
         let offsets = HorizontalOffsets::from_layout_texts(paragraph, &texts, offset_map);
@@ -386,6 +395,8 @@ impl HorizontalParagraphPlan {
             offsets,
             sheds,
             ruby_spacing,
+            emergency_breaks: emergency.to_vec(),
+            overflow_width: None,
         }
     }
 }
diff --git a/render-wasm/src/shapes/text_horizontal/offsets.rs b/render-wasm/src/shapes/text_horizontal/offsets.rs
index 6b06581c31..bd67b7f94e 100644
--- a/render-wasm/src/shapes/text_horizontal/offsets.rs
+++ b/render-wasm/src/shapes/text_horizontal/offsets.rs
@@ -24,6 +24,7 @@ pub(crate) struct HorizontalOffsets {
 }
 
 impl HorizontalOffsets {
+    #[cfg(test)]
     pub(crate) fn new(paragraph: &Paragraph) -> Self {
         let (span_texts, offset_map) = paragraph.layout_span_texts();
         Self::from_layout_texts(paragraph, &span_texts, offset_map)
@@ -81,8 +82,15 @@ impl HorizontalOffsets {
 
     /// Paragraph source character offset of a builder-text UTF-16 offset.
     pub(crate) fn builder_to_source(&self, builder_offset: usize) -> usize {
-        let source_utf16 = self
-            .ranges
+        let source_utf16 = self.builder_to_transformed(builder_offset);
+        let boundaries = &self.boundaries;
+        boundaries
+            .partition_point(|boundary| *boundary < source_utf16)
+            .min(boundaries.len().saturating_sub(1))
+    }
+
+    pub(super) fn builder_to_transformed(&self, builder_offset: usize) -> usize {
+        self.ranges
             .iter()
             .find(|range| {
                 builder_offset >= range.builder_start && builder_offset <= range.builder_end
@@ -106,11 +114,7 @@ impl HorizontalOffsets {
                     .last()
                     .map(|range| range.source_end)
                     .unwrap_or(0)
-            });
-        let boundaries = &self.boundaries;
-        boundaries
-            .partition_point(|boundary| *boundary < source_utf16)
-            .min(boundaries.len().saturating_sub(1))
+            })
     }
 
     /// Builder-text ranges of the selected source characters
@@ -172,11 +176,28 @@ fn span_ranges(
             let source_start = offset_map.to_original(shifted_start);
             let source_end = offset_map.to_original(shifted_end);
             let warichu = span.is_warichu();
+            let leading_break =
+                usize::from(warichu && text.starts_with(kinsoku::FORCED_LINE_BREAK));
+            builder_cursor += leading_break;
+            builder_byte_cursor += leading_break * kinsoku::FORCED_LINE_BREAK.len_utf8();
             let builder_start = builder_cursor;
             let style_anchor_start = if warichu {
                 builder_byte_cursor + '\u{FFFC}'.len_utf8()
             } else {
+                // A forced separator belongs to the preceding line and has
+                // no style metrics. Anchor annotations to the first source
+                // character rather than a leading layout-only control.
+                let mut shifted = shifted_start;
                 builder_byte_cursor
+                    + text
+                        .chars()
+                        .take_while(|ch| {
+                            let inserted = offset_map.is_inserted(shifted);
+                            shifted += ch.len_utf16();
+                            inserted
+                        })
+                        .map(char::len_utf8)
+                        .sum::<usize>()
             };
             builder_cursor += if warichu {
                 HORIZONTAL_WARICHU_BUILDER_LEN
diff --git a/render-wasm/src/shapes/text_horizontal/overflow.rs b/render-wasm/src/shapes/text_horizontal/overflow.rs
new file mode 100644
index 0000000000..5116689067
--- /dev/null
+++ b/render-wasm/src/shapes/text_horizontal/overflow.rs
@@ -0,0 +1,171 @@
+//! Repair SkParagraph's emergency splits without changing the wrap budget.
+
+use super::*;
+
+impl HorizontalParagraphPlan {
+    /// Keep an indivisible unit together even when Skia's last-resort wrapping
+    /// ignores its joiners. Isolate overflowing units, measure the surrounding
+    /// text at the original width, and freeze those legal line starts before
+    /// increasing Skia's physical width. All consumers use this same plan.
+    pub(crate) fn retain_atomic_overflow(
+        &mut self,
+        paragraph: &Paragraph,
+        width: f32,
+        mut measure: impl FnMut(&Self, f32) -> skia::textlayout::Paragraph,
+    ) {
+        use unicode_segmentation::UnicodeSegmentation;
+        let policy = paragraph.layout_policy();
+        if !(policy.is_chinese()
+            || matches!(
+                policy,
+                TextLayoutPolicy::KoreanWords | TextLayoutPolicy::KoreanSyllable
+            ))
+            || !width.is_finite()
+            || width <= 0.0
+            || width == f32::MAX
+        {
+            return;
+        }
+        let source: String = paragraph
+            .children()
+            .iter()
+            .map(TextSpan::apply_text_transform)
+            .collect();
+        let mut length = 0;
+        let graphemes: Vec<_> = source
+            .graphemes(true)
+            .map(|g| {
+                let start = length;
+                length += g.encode_utf16().count();
+                (start, g.chars().next().unwrap())
+            })
+            .collect();
+        let mut offset = 0;
+        let protected: Vec<_> = paragraph
+            .children()
+            .iter()
+            .filter_map(|span| {
+                let start = offset;
+                offset += span.apply_text_transform().encode_utf16().count();
+                (span.has_ruby() || span.is_warichu()).then_some(start..offset)
+            })
+            .collect();
+        let hard_break = |c| matches!(c, '\n' | '\r' | '\u{2028}' | '\u{2029}');
+        let mut units = Vec::new();
+        let mut start = 0;
+        for at in 1..graphemes.len() {
+            let (position, after) = graphemes[at];
+            let before = graphemes[at - 1].1;
+            let annotation = protected
+                .get(protected.partition_point(|r| r.end <= position))
+                .is_some_and(|r| r.start < position);
+            if hard_break(before)
+                || hard_break(after)
+                || (!annotation && policy.emergency_break_allowed(before, after))
+            {
+                if at - start > 1 {
+                    units.push(graphemes[start].0..position);
+                }
+                start = at;
+            }
+        }
+        if graphemes.len() - start > 1 {
+            units.push(graphemes[start].0..length);
+        }
+        if units.is_empty() {
+            return;
+        }
+        let bounded = measure(self, width);
+        let starts: Vec<_> = bounded
+            .get_line_metrics()
+            .iter()
+            .skip(1)
+            .map(|line| self.offsets.builder_to_transformed(line.start_index))
+            .collect();
+        units.retain(|unit| {
+            starts
+                .get(starts.partition_point(|at| *at <= unit.start))
+                .is_some_and(|at| *at < unit.end)
+        });
+        if units.is_empty() {
+            return;
+        }
+        let natural = measure(self, f32::MAX);
+        let mut physical_width = width;
+        units.retain(|unit| {
+            let from = self.offsets.transformed_to_builder(unit.start);
+            let to = self.offsets.transformed_to_builder(unit.end);
+            let extent: f32 = natural
+                .get_rects_for_range(from..to, RectHeightStyle::Tight, RectWidthStyle::Tight)
+                .iter()
+                .map(|box_| box_.rect.width())
+                .sum();
+            if extent <= width + 0.01 {
+                return false;
+            }
+            physical_width = physical_width.max(extent);
+            true
+        });
+        if units.is_empty() {
+            return;
+        }
+        let can_insert = |at: usize| {
+            at > 0
+                && at < length
+                && graphemes
+                    .binary_search_by_key(&at, |g| g.0)
+                    .ok()
+                    .is_some_and(|i| !hard_break(graphemes[i].1) && !hard_break(graphemes[i - 1].1))
+        };
+        let mut forced: Vec<_> = units
+            .iter()
+            .flat_map(|unit| [unit.start, unit.end])
+            .filter(|at| can_insert(*at))
+            .collect();
+        forced.sort_unstable();
+        forced.dedup();
+        let isolated = Self::with_breaks(paragraph, &self.emergency_breaks, &forced);
+        let bounded = measure(&isolated, width);
+        physical_width = physical_width.max(bounded.longest_line());
+        forced.extend(
+            bounded
+                .get_line_metrics()
+                .iter()
+                .skip(1)
+                .map(|line| isolated.offsets.builder_to_transformed(line.start_index))
+                .filter(|at| {
+                    can_insert(*at)
+                        && units
+                            .get(units.partition_point(|unit| unit.end <= *at))
+                            .is_none_or(|unit| *at <= unit.start)
+                }),
+        );
+        forced.sort_unstable();
+        forced.dedup();
+        *self = Self::with_breaks(paragraph, &self.emergency_breaks, &forced);
+        // Avoid a floating-point edge reintroducing the very fallback being
+        // repaired. The epsilon changes physical width, not the wrap budget.
+        self.overflow_width = Some(physical_width + 0.01);
+    }
+
+    pub(crate) fn layout_width(&self, width: f32) -> f32 {
+        self.overflow_width.unwrap_or(width)
+    }
+
+    /// Skia aligns against the physical width; translate it back to the box.
+    pub(crate) fn x_offset(&self, paragraph: &Paragraph, width: f32) -> f32 {
+        use skia::textlayout::{TextAlign, TextDirection};
+        let slack = width - self.layout_width(width);
+        match paragraph.text_align() {
+            TextAlign::Center => slack * 0.5,
+            TextAlign::Right => slack,
+            TextAlign::Start if paragraph.text_direction() == TextDirection::RTL => slack,
+            TextAlign::End if paragraph.text_direction() == TextDirection::LTR => slack,
+            _ => 0.0,
+        }
+    }
+
+    pub(crate) fn has_atomic_overflow(&self) -> bool {
+        self.overflow_width.is_some()
+    }
+}
diff --git a/render-wasm/src/shapes/text_horizontal/ruby.rs b/render-wasm/src/shapes/text_horizontal/ruby.rs
index 8dce91944f..847db2b7f9 100644
--- a/render-wasm/src/shapes/text_horizontal/ruby.rs
+++ b/render-wasm/src/shapes/text_horizontal/ruby.rs
@@ -295,7 +295,12 @@ pub(super) fn horizontal_ruby_targets(
         .iter()
         .zip(&offsets.ranges)
         .filter(|(span, range)| span.has_ruby() && range.builder_start < range.builder_end)
-        .map(|(_, range)| (range.span, range.builder_start..range.builder_end))
+        .map(|(_, range)| {
+            (
+                range.span,
+                offsets.transformed_to_builder(range.source_start)..range.builder_end,
+            )
+        })
         .collect()
 }
 
diff --git a/render-wasm/src/shapes/text_horizontal/tests.rs b/render-wasm/src/shapes/text_horizontal/tests.rs
index 3d7f77ae85..3124987665 100644
--- a/render-wasm/src/shapes/text_horizontal/tests.rs
+++ b/render-wasm/src/shapes/text_horizontal/tests.rs
@@ -33,11 +33,20 @@ fn cjk_horizontal_layout(
     let mut paragraph = make_paragraph(spans, 0.0);
     paragraph.set_language(language.to_owned());
     paragraph.set_korean_wrap(wrap);
-    let mut plan = HorizontalParagraphPlan::new(&paragraph);
+    let (plan, layout) = cjk_layout_paragraph(&paragraph, width, &fonts);
+    (paragraph, plan, layout)
+}
+
+fn cjk_layout_paragraph(
+    paragraph: &Paragraph,
+    width: f32,
+    fonts: &skia::textlayout::FontCollection,
+) -> (HorizontalParagraphPlan, skia::textlayout::Paragraph) {
+    let mut plan = HorizontalParagraphPlan::new(paragraph);
     let lay_out = |plan: &HorizontalParagraphPlan, width: f32| {
         let mut paragraph_style = paragraph.paragraph_to_style();
         paragraph_style.set_apply_rounding_hack(false);
-        let mut builder = ParagraphBuilder::new(&paragraph_style, &fonts);
+        let mut builder = ParagraphBuilder::new(&paragraph_style, fonts);
         for (index, span) in paragraph.children().iter().enumerate() {
             let style = span.to_style(
                 &crate::math::Rect::from_xywh(0.0, 0.0, width, 200.0),
@@ -51,9 +60,9 @@ fn cjk_horizontal_layout(
                 span,
                 &plan.texts[index],
                 &plan.sheds[index],
-                &[],
+                &plan.ruby_spacing.adjustments[index],
                 &style,
-                &fonts,
+                fonts,
             );
             builder.pop();
         }
@@ -61,9 +70,10 @@ fn cjk_horizontal_layout(
         layout.layout(width);
         layout
     };
-    plan.relax_overlong_words(&paragraph, width, |plan| lay_out(plan, width));
-    let layout = lay_out(&plan, width);
-    (paragraph, plan, layout)
+    plan.relax_overlong_words(paragraph, width, |plan| lay_out(plan, width));
+    plan.retain_atomic_overflow(paragraph, width, lay_out);
+    let layout = lay_out(&plan, plan.layout_width(width));
+    (plan, layout)
 }
 
 #[test]
@@ -222,10 +232,9 @@ fn cjk_emergency_wrapping_keeps_safe_boundaries_across_box_widths() {
 #[test]
 fn narrower_than_atomic_unit_layout_keeps_source_offsets_and_finite_geometry() {
     use crate::shapes::text_policy::KoreanWrap;
-    // These widths cannot fit the punctuation unit. This checks data safety;
-    // it does not claim SkParagraph retains the policy's forbidden boundaries.
+    // Overflow preserves both the punctuation rule and editable positions.
     for language in ["zh-Hant-TW", "ko"] {
-        for width in [1.0, 10.0, 19.0, 20.0, 30.0, 39.0] {
+        for width in [1.0, 10.0, 19.0, 20.0, 30.0, 39.0, 39.999] {
             let (paragraph, plan, layout) =
                 cjk_horizontal_layout(&["文", "。"], language, KoreanWrap::KeepWords, width);
             let original = HorizontalParagraphPlan::new(&paragraph);
@@ -234,6 +243,7 @@ fn narrower_than_atomic_unit_layout_keeps_source_offsets_and_finite_geometry() {
                 assert_eq!(plan.offsets.builder_to_source(builder), at);
                 assert_eq!(builder, original.offsets.source_to_builder(at));
             }
+            assert_eq!(layout.get_line_metrics().len(), 1);
             assert!(layout.height().is_finite() && layout.height() > 0.0);
             for line in layout.get_line_metrics() {
                 assert!(line.width.is_finite() && line.width >= 0.0);
@@ -1603,3 +1613,171 @@ fn horizontal_zhuyin_reserves_its_right_strip_without_changing_line_leading() {
         assert_eq!(origin.y, 0.0);
     }
 }
+
+#[test]
+fn horizontal_indivisible_punctuation_unit_overflows_a_narrow_box() {
+    use crate::shapes::text_policy::KoreanWrap;
+    for language in ["zh-Hant-TW", "zh-Hans-CN", "zh-Hant-HK", "ko"] {
+        let (_, plan, layout) =
+            cjk_horizontal_layout(&["文", "。"], language, KoreanWrap::KeepWords, 20.0);
+        let starts: Vec<_> = layout
+            .get_line_metrics()
+            .iter()
+            .map(|line| plan.offsets.builder_to_source(line.start_index))
+            .collect();
+        assert_eq!(
+            starts,
+            vec![0],
+            "{language}: a closing mark must stay with its base"
+        );
+        assert!(
+            layout.longest_line() > 20.0,
+            "the unit overflows rather than splitting"
+        );
+    }
+}
+
+#[test]
+fn narrow_atomic_overflow_retains_normal_wrap_budget_and_explicit_newlines() {
+    use crate::shapes::text_policy::KoreanWrap;
+    for language in ["zh-Hant-TW", "zh-Hans-CN", "zh-Hant-HK", "ko"] {
+        for (texts, expected) in [
+            (vec!["文文文", "。", "文文文"], vec![0, 1, 2, 4, 5, 6]),
+            (vec!["文\n", "文", "。", "\n文"], vec![0, 2, 5]),
+            (vec!["文（", "文）", "文文"], vec![0, 1, 4, 5]),
+        ] {
+            let (paragraph, plan, layout) =
+                cjk_horizontal_layout(&texts, language, KoreanWrap::KeepWords, 20.0);
+            let starts: Vec<_> = layout
+                .get_line_metrics()
+                .iter()
+                .map(|line| plan.offsets.builder_to_source(line.start_index))
+                .collect();
+            assert_eq!(starts, expected, "{language}: {texts:?}");
+            for at in 0..=paragraph
+                .children()
+                .iter()
+                .map(|s| s.text.chars().count())
+                .sum()
+            {
+                assert_eq!(
+                    plan.offsets
+                        .builder_to_source(plan.offsets.source_to_builder(at)),
+                    at
+                );
+            }
+            assert_eq!(
+                paragraph
+                    .children()
+                    .iter()
+                    .map(|s| s.text.as_str())
+                    .collect::<String>(),
+                texts.concat()
+            );
+        }
+    }
+}
+
+#[test]
+fn narrow_atomic_units_preserve_controls_numeric_expressions_and_graphemes() {
+    use crate::shapes::text_policy::KoreanWrap;
+    for language in ["zh-Hant-TW", "zh-Hans-CN", "zh-Hant-HK", "ko"] {
+        for unit in [
+            "文。",
+            "（文）",
+            "$1.5%",
+            "1℃",
+            "文\u{a0}文",
+            "文\u{2060}文",
+            "e\u{301}。",
+            "😀。",
+            "👩‍👩‍👧‍👦。",
+        ] {
+            for width in [1.0, 10.0, 20.0, 29.0, 39.0] {
+                let source = format!("文文{unit}文文");
+                let (_, plan, layout) =
+                    cjk_horizontal_layout(&[&source], language, KoreanWrap::KeepWords, width);
+                let end = 2 + unit.chars().count();
+                for line in layout.get_line_metrics().iter().skip(1) {
+                    let at = plan.offsets.builder_to_source(line.start_index);
+                    assert!(
+                        !(2 < at && at < end),
+                        "{language} {width}px breaks {unit} at {at}"
+                    );
+                }
+                assert!(
+                    layout
+                        .get_line_metrics()
+                        .iter()
+                        .all(|line| line.width > 0.0),
+                    "no synthetic empty lines in {source}"
+                );
+                for at in 0..=source.chars().count() {
+                    assert_eq!(
+                        plan.offsets
+                            .builder_to_source(plan.offsets.source_to_builder(at)),
+                        at,
+                        "{source} at {at}"
+                    );
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn narrow_atomic_overflow_keeps_ruby_and_warichu_with_their_closing_marks() {
+    use crate::shapes::text_vertical::test_support::provider;
+    init_state();
+    let mut fonts = skia::textlayout::FontCollection::new();
+    fonts.set_asset_font_manager(Some(
+        provider(include_bytes!("../../fonts/cjk-locl-test.ttf")).into(),
+    ));
+    let mut resources =
+        crate::render::RenderResources::try_new_headless().expect("headless resources");
+    let _guard = crate::globals::TestRenderResourcesGuard::install(&mut resources);
+    for warichu in [false, true] {
+        let mut annotation = make_span("文文文文", 0.0);
+        annotation.font_size = 20.0;
+        annotation.warichu = warichu;
+        if !warichu {
+            annotation.ruby = "wén wén".to_string();
+        }
+        let mut paragraph = make_paragraph(
+            vec![make_span("文文", 0.0), annotation, make_span("。文文", 0.0)],
+            0.0,
+        );
+        paragraph.set_language("zh-Hant-TW".to_string());
+        let (plan, layout) = cjk_layout_paragraph(&paragraph, 20.0, &fonts);
+        let starts: Vec<_> = layout
+            .get_line_metrics()
+            .iter()
+            .map(|line| plan.offsets.builder_to_source(line.start_index))
+            .collect();
+        assert_eq!(starts, vec![0, 1, 2, 7, 8], "warichu={warichu}");
+        for at in [0, 1, 2, 6, 7, 8, 9] {
+            assert_eq!(
+                plan.offsets
+                    .builder_to_source(plan.offsets.source_to_builder(at)),
+                at,
+                "warichu={warichu}, {at}"
+            );
+        }
+        assert!(
+            horizontal_span_style(&layout, &plan.offsets.ranges[1]).is_some(),
+            "warichu={warichu}"
+        );
+        if !warichu {
+            let targets = horizontal_ruby_targets(&paragraph, &plan.offsets);
+            assert_eq!(targets.len(), 1);
+            let rects = layout.get_rects_for_range(
+                targets[0].1.clone(),
+                RectHeightStyle::Tight,
+                RectWidthStyle::Tight,
+            );
+            assert!(rects
+                .iter()
+                .all(|r| (r.rect.top() - rects[0].rect.top()).abs() < 0.01));
+        }
+    }
+}
diff --git a/render-wasm/src/shapes/text_paths.rs b/render-wasm/src/shapes/text_paths.rs
index 2f4f24921f..985446a831 100644
--- a/render-wasm/src/shapes/text_paths.rs
+++ b/render-wasm/src/shapes/text_paths.rs
@@ -28,13 +28,15 @@ impl TextPaths {
         }
 
         let layout_width = self.0.get_width(self.bounds.width());
+        let plans = self.0.horizontal_plans();
         let mut paragraph_builders = self.0.paragraph_builder_group_from_text(None);
         let mut paragraphs: Vec<SkiaParagraph> = paragraph_builders
             .iter_mut()
             .filter_map(|group| group.first_mut())
-            .map(|paragraph_builder| {
+            .enumerate()
+            .map(|(index, paragraph_builder)| {
                 let mut paragraph = paragraph_builder.build();
-                paragraph.layout(layout_width);
+                paragraph.layout(plans[index].layout_width(layout_width));
                 paragraph
             })
             .collect();
@@ -44,9 +46,21 @@ impl TextPaths {
             + vertical_align_offset(self.bounds.height(), total_height, vertical_align);
 
         let mut paths = Vec::new();
-        for (paragraph, text_paragraph) in paragraphs.iter_mut().zip(self.0.paragraphs()) {
-            let origin = Point::new(self.bounds.x(), offset_y);
-            Self::collect_paragraph_paths(paragraph, text_paragraph, origin, &mut paths);
+        for (index, (paragraph, text_paragraph)) in
+            paragraphs.iter_mut().zip(self.0.paragraphs()).enumerate()
+        {
+            let plan = &plans[index];
+            let origin = Point::new(
+                self.bounds.x() + plan.x_offset(text_paragraph, layout_width),
+                offset_y,
+            );
+            Self::collect_paragraph_paths(
+                paragraph,
+                text_paragraph,
+                &plan.offsets,
+                origin,
+                &mut paths,
+            );
             offset_y += paragraph.height();
         }
 
@@ -56,11 +70,11 @@ impl TextPaths {
     fn collect_paragraph_paths(
         paragraph: &mut SkiaParagraph,
         text_paragraph: &Paragraph,
+        offsets: &crate::shapes::HorizontalOffsets,
         origin: Point,
         paths: &mut Vec<skia::Path>,
     ) {
-        let offsets = crate::shapes::HorizontalOffsets::new(text_paragraph);
-        for deco in decoration_segments(paragraph, text_paragraph, &offsets, origin.x, origin.y) {
+        for deco in decoration_segments(paragraph, text_paragraph, offsets, origin.x, origin.y) {
             let mut builder = skia::PathBuilder::new();
             builder.add_rect(deco.rect(), None, None);
             paths.push(builder.detach());