perf: improve ctd

koharu-app/src/llm.rs

@@ -26,17 +26,19 @@ use crate::config as app_config;
 
 pub use koharu_llm::prefetch;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-struct BlockStartTag {
-    offset: usize,
-    len: usize,
-    id: usize,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-struct BlockEndTag {
-    offset: usize,
-    len: usize,
+/// Matches a `<|N|>` tag, returning (full match length, 0-based index).
+fn parse_block_tag(text: &str) -> Option<(usize, usize)> {
+    let bytes = text.as_bytes();
+    if bytes.get(0..2)? != b"<|" {
+        return None;
+    }
+    let end = text[2..].find("|>")?;
+    let num_str = &text[2..2 + end];
+    let id_1based: usize = num_str.parse().ok()?;
+    if id_1based == 0 {
+        return None;
+    }
+    Some((2 + end + 2, id_1based - 1))
 }
 
 #[allow(clippy::large_enum_variant)]
@@ -125,18 +127,6 @@ fn state_target(state: &State) -> Option<LlmTarget> {
     }
 }
 
-fn escape_block_text(text: &str) -> String {
-    text.replace('&', "&amp;")
-        .replace('<', "&lt;")
-        .replace('>', "&gt;")
-}
-
-fn unescape_block_text(text: &str) -> String {
-    text.replace("&lt;", "<")
-        .replace("&gt;", ">")
-        .replace("&amp;", "&")
-}
-
 fn strip_wrapping_quotes(text: &str) -> String {
     let mut current = text.trim();
 
@@ -194,22 +184,29 @@ fn format_document_blocks(blocks: &[TextBlock]) -> String {
         .enumerate()
         .map(|(idx, block)| {
             let text = block.text.as_deref().unwrap_or("<empty>");
-            format!(
-                r#"<block id="{idx}">
-{}
-</block>"#,
-                escape_block_text(text)
-            )
+            format!("<|{}|>{}", idx + 1, text)
         })
         .collect::<Vec<_>>()
         .join("\n")
 }
 
+fn find_next_tag(text: &str) -> Option<(usize, usize, usize)> {
+    let mut pos = 0;
+    while let Some(rel) = text[pos..].find("<|") {
+        let offset = pos + rel;
+        if let Some((len, id)) = parse_block_tag(&text[offset..]) {
+            return Some((offset, len, id));
+        }
+        pos = offset + 1;
+    }
+    None
+}
+
 fn parse_tagged_blocks(
     translation: &str,
     expected_blocks: usize,
 ) -> anyhow::Result<Option<Vec<String>>> {
-    if find_next_block_start_tag(translation).is_none() {
+    if find_next_tag(translation).is_none() {
         return Ok(None);
     }
 
@@ -219,42 +216,29 @@ fn parse_tagged_blocks(
     let mut parsed_count = 0usize;
     let mut ignored_count = 0usize;
 
-    while let Some(start_tag) = find_next_block_start_tag(cursor) {
+    while let Some((offset, len, id)) = find_next_tag(cursor) {
         found_any = true;
-        cursor = &cursor[start_tag.offset + start_tag.len..];
+        cursor = &cursor[offset + len..];
+
+        // Find content: everything until the next tag or end of string
+        let content_end = find_next_tag(cursor)
+            .map(|(next_offset, _, _)| next_offset)
+            .unwrap_or(cursor.len());
+        let content = cursor[..content_end].trim().to_string();
 
-        let id = start_tag.id;
         if id >= expected_blocks {
             ignored_count += 1;
             tracing::warn!("Ignoring translated block id {id} for {expected_blocks} source blocks");
-            let closing_tag = find_next_block_end_tag(cursor);
-            let boundary = block_boundary(cursor, closing_tag.map(|tag| tag.offset));
-            cursor = if closing_tag.map(|tag| tag.offset) == Some(boundary) {
-                let closing_len = closing_tag.map(|tag| tag.len).unwrap_or(0);
-                &cursor[boundary + closing_len..]
-            } else {
-                &cursor[boundary..]
-            };
-            continue;
-        }
-
-        let closing_tag = find_next_block_end_tag(cursor);
-        let block_end = block_boundary(cursor, closing_tag.map(|tag| tag.offset));
-        let content = unescape_block_text(cursor[..block_end].trim());
-
-        if blocks[id].is_empty() {
-            parsed_count += 1;
         } else {
-            tracing::warn!("Translated block id {id} appeared more than once, keeping latest");
+            if blocks[id].is_empty() {
+                parsed_count += 1;
+            } else {
+                tracing::warn!("Translated block id {id} appeared more than once, keeping latest");
+            }
+            blocks[id] = content;
         }
-        blocks[id] = content;
 
-        cursor = if closing_tag.map(|tag| tag.offset) == Some(block_end) {
-            let closing_len = closing_tag.map(|tag| tag.len).unwrap_or(0);
-            &cursor[block_end + closing_len..]
-        } else {
-            &cursor[block_end..]
-        };
+        cursor = &cursor[content_end..];
     }
 
     if !found_any {
@@ -297,151 +281,6 @@ fn split_legacy_lines(translation: &str, expected_blocks: usize) -> anyhow::Resu
     Ok(translations)
 }
 
-fn block_boundary(cursor: &str, closing_tag: Option<usize>) -> usize {
-    let next_block_start = find_next_block_start_tag(cursor).map(|tag| tag.offset);
-    match (closing_tag, next_block_start) {
-        (Some(close), Some(next)) => close.min(next),
-        (Some(close), None) => close,
-        (None, Some(next)) => next,
-        (None, None) => cursor.len(),
-    }
-}
-
-fn find_next_block_start_tag(text: &str) -> Option<BlockStartTag> {
-    let mut search_from = 0usize;
-    while let Some(rel_start) = text[search_from..].find('<') {
-        let offset = search_from + rel_start;
-        if let Some((len, id)) = parse_block_start_tag(&text[offset..]) {
-            return Some(BlockStartTag { offset, len, id });
-        }
-        search_from = offset + 1;
-    }
-    None
-}
-
-fn parse_block_start_tag(text: &str) -> Option<(usize, usize)> {
-    let bytes = text.as_bytes();
-    if bytes.first().copied()? != b'<' {
-        return None;
-    }
-
-    let mut index = 1usize;
-    skip_ascii_whitespace(bytes, &mut index);
-    if !consume_ascii_keyword(bytes, &mut index, "block") {
-        return None;
-    }
-
-    let mut parsed_id = None;
-    loop {
-        skip_ascii_whitespace(bytes, &mut index);
-        match bytes.get(index).copied()? {
-            b'>' => return parsed_id.map(|id| (index + 1, id)),
-            b'/' if bytes.get(index + 1).copied() == Some(b'>') => {
-                return parsed_id.map(|id| (index + 2, id));
-            }
-            _ => {}
-        }
-
-        let name_start = index;
-        while matches!(
-            bytes.get(index).copied(),
-            Some(b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'-')
-        ) {
-            index += 1;
-        }
-        if index == name_start {
-            return None;
-        }
-        let attr_name = &text[name_start..index];
-
-        skip_ascii_whitespace(bytes, &mut index);
-        if bytes.get(index).copied()? != b'=' {
-            return None;
-        }
-        index += 1;
-        skip_ascii_whitespace(bytes, &mut index);
-
-        let attr_value = match bytes.get(index).copied()? {
-            b'"' | b'\'' => {
-                let quote = bytes[index];
-                index += 1;
-                let value_start = index;
-                while bytes.get(index).copied()? != quote {
-                    index += 1;
-                }
-                let value = &text[value_start..index];
-                index += 1;
-                value
-            }
-            _ => {
-                let value_start = index;
-                while matches!(bytes.get(index).copied(), Some(byte) if !byte.is_ascii_whitespace() && byte != b'>')
-                {
-                    index += 1;
-                }
-                &text[value_start..index]
-            }
-        };
-
-        if attr_name.eq_ignore_ascii_case("id") {
-            parsed_id = attr_value.parse::<usize>().ok();
-        }
-    }
-}
-
-fn find_next_block_end_tag(text: &str) -> Option<BlockEndTag> {
-    let mut search_from = 0usize;
-    while let Some(rel_start) = text[search_from..].find('<') {
-        let offset = search_from + rel_start;
-        if let Some(len) = parse_block_end_tag(&text[offset..]) {
-            return Some(BlockEndTag { offset, len });
-        }
-        search_from = offset + 1;
-    }
-    None
-}
-
-fn parse_block_end_tag(text: &str) -> Option<usize> {
-    let bytes = text.as_bytes();
-    if bytes.first().copied()? != b'<' {
-        return None;
-    }
-
-    let mut index = 1usize;
-    skip_ascii_whitespace(bytes, &mut index);
-    if bytes.get(index).copied()? != b'/' {
-        return None;
-    }
-    index += 1;
-    skip_ascii_whitespace(bytes, &mut index);
-    if !consume_ascii_keyword(bytes, &mut index, "block") {
-        return None;
-    }
-    skip_ascii_whitespace(bytes, &mut index);
-    if bytes.get(index).copied()? != b'>' {
-        return None;
-    }
-    Some(index + 1)
-}
-
-fn skip_ascii_whitespace(bytes: &[u8], index: &mut usize) {
-    while matches!(bytes.get(*index).copied(), Some(byte) if byte.is_ascii_whitespace()) {
-        *index += 1;
-    }
-}
-
-fn consume_ascii_keyword(bytes: &[u8], index: &mut usize, keyword: &str) -> bool {
-    let end = *index + keyword.len();
-    let Some(slice) = bytes.get(*index..end) else {
-        return false;
-    };
-    if !slice.eq_ignore_ascii_case(keyword.as_bytes()) {
-        return false;
-    }
-    *index = end;
-    true
-}
-
 impl Translatable for Document {
     fn get_source(&self) -> anyhow::Result<String> {
         Ok(format_document_blocks(&self.text_blocks))
@@ -466,12 +305,7 @@ impl Translatable for TextBlock {
             .text
             .clone()
             .ok_or_else(|| anyhow::anyhow!("No source text found"))?;
-        Ok(format!(
-            r#"<block id="0">
-{}
-</block>"#,
-            escape_block_text(&source)
-        ))
+        Ok(format!("<|1|>{}", source))
     }
 
     fn set_translation(&mut self, translation: String) -> anyhow::Result<()> {
@@ -929,10 +763,7 @@ mod tests {
         };
 
         let source = doc.get_source()?;
-        assert_eq!(
-            source,
-            "<block id=\"0\">\nHello\n</block>\n<block id=\"1\">\n1 &lt; 2\nA &amp; B\n</block>"
-        );
+        assert_eq!(source, "<|1|>Hello\n<|2|>1 < 2\nA & B");
 
         Ok(())
     }
@@ -944,9 +775,7 @@ mod tests {
             ..Default::default()
         };
 
-        doc.set_translation(
-            "<block id=\"1\">\nSecond line\nnext\n</block>\n<block id=\"0\">\nFirst &lt;done&gt;\n</block>".to_string(),
-        )?;
+        doc.set_translation("<|2|>Second line\nnext\n<|1|>First <done>".to_string())?;
 
         assert_eq!(
             doc.text_blocks[0].translation.as_deref(),
@@ -967,10 +796,7 @@ mod tests {
             ..Default::default()
         };
 
-        doc.set_translation(
-            "<block id=\"0\">\n\"Hello\"\n</block>\n<block id=\"1\">\n“World”\n</block>"
-                .to_string(),
-        )?;
+        doc.set_translation("<|1|>\"Hello\"\n<|2|>\u{201c}World\u{201d}".to_string())?;
 
         assert_eq!(doc.text_blocks[0].translation.as_deref(), Some("Hello"));
         assert_eq!(doc.text_blocks[1].translation.as_deref(), Some("World"));
@@ -997,15 +823,13 @@ mod tests {
     }
 
     #[test]
-    fn document_translation_allows_missing_closing_tags() -> anyhow::Result<()> {
+    fn document_translation_parses_consecutive_tags() -> anyhow::Result<()> {
         let mut doc = Document {
             text_blocks: vec![TextBlock::default(), TextBlock::default()],
             ..Default::default()
         };
 
-        doc.set_translation(
-            "<block id=\"0\">\nFirst line\n<block id=\"1\">\nSecond line".to_string(),
-        )?;
+        doc.set_translation("<|1|>First line\n<|2|>Second line".to_string())?;
 
         assert_eq!(
             doc.text_blocks[0].translation.as_deref(),
@@ -1020,14 +844,13 @@ mod tests {
     }
 
     #[test]
-    fn document_translation_uses_end_of_text_when_last_closing_tag_is_missing() -> anyhow::Result<()>
-    {
+    fn document_translation_uses_end_of_text_for_last_block() -> anyhow::Result<()> {
         let mut doc = Document {
             text_blocks: vec![TextBlock::default()],
             ..Default::default()
         };
 
-        doc.set_translation("<block id=\"0\">\nFinal line".to_string())?;
+        doc.set_translation("<|1|>Final line".to_string())?;
 
         assert_eq!(
             doc.text_blocks[0].translation.as_deref(),
@@ -1044,49 +867,13 @@ mod tests {
             ..Default::default()
         };
 
-        doc.set_translation(
-            "<block id=\"0\">\nKept\n</block>\n<block id=\"1\">\nIgnored\n</block>".to_string(),
-        )?;
+        doc.set_translation("<|1|>Kept\n<|2|>Ignored".to_string())?;
 
         assert_eq!(doc.text_blocks[0].translation.as_deref(), Some("Kept"));
 
         Ok(())
     }
 
-    #[test]
-    fn document_translation_accepts_relaxed_block_tag_formatting() -> anyhow::Result<()> {
-        let mut doc = Document {
-            text_blocks: vec![TextBlock::default(), TextBlock::default()],
-            ..Default::default()
-        };
-
-        doc.set_translation(
-            "<block id = '1' >\nSecond\n</ block>\n<Block id=0>\nFirst\n</BLOCK>".to_string(),
-        )?;
-
-        assert_eq!(doc.text_blocks[0].translation.as_deref(), Some("First"));
-        assert_eq!(doc.text_blocks[1].translation.as_deref(), Some("Second"));
-
-        Ok(())
-    }
-
-    #[test]
-    fn document_translation_accepts_unquoted_block_ids() -> anyhow::Result<()> {
-        let mut doc = Document {
-            text_blocks: vec![TextBlock::default()],
-            ..Default::default()
-        };
-
-        doc.set_translation("<block id=0>\nOnly first\n</block>".to_string())?;
-
-        assert_eq!(
-            doc.text_blocks[0].translation.as_deref(),
-            Some("Only first")
-        );
-
-        Ok(())
-    }
-
     #[test]
     fn document_translation_pads_missing_tagged_blocks() -> anyhow::Result<()> {
         let mut doc = Document {
@@ -1094,7 +881,7 @@ mod tests {
             ..Default::default()
         };
 
-        doc.set_translation("<block id=\"0\">\nOnly first\n</block>".to_string())?;
+        doc.set_translation("<|1|>Only first".to_string())?;
 
         assert_eq!(
             doc.text_blocks[0].translation.as_deref(),
@@ -1108,7 +895,7 @@ mod tests {
     #[test]
     fn text_block_translation_strips_wrapping_quotes() -> anyhow::Result<()> {
         let mut block = TextBlock::default();
-        block.set_translation("“quoted”".to_string())?;
+        block.set_translation("\u{201c}quoted\u{201d}".to_string())?;
         assert_eq!(block.translation.as_deref(), Some("quoted"));
         Ok(())
     }
@@ -1121,7 +908,7 @@ mod tests {
         };
 
         let source = block.get_source()?;
-        assert_eq!(source, "<block id=\"0\">\n1 &lt; 2\nA &amp; B\n</block>");
+        assert_eq!(source, "<|1|>1 < 2\nA & B");
 
         Ok(())
     }
@@ -1129,10 +916,8 @@ mod tests {
     #[test]
     fn text_block_translation_extracts_tagged_block_content() -> anyhow::Result<()> {
         let mut block = TextBlock::default();
-        block.set_translation(
-            "Sure.\n<block id=\"0\">\nTranslated &lt;line&gt;\n</block>\nDone.".to_string(),
-        )?;
-        assert_eq!(block.translation.as_deref(), Some("Translated <line>"));
+        block.set_translation("Sure.\n<|1|>Translated text".to_string())?;
+        assert_eq!(block.translation.as_deref(), Some("Translated text"));
         Ok(())
     }
 
@@ -1150,8 +935,23 @@ mod tests {
     #[test]
     fn text_block_translation_keeps_japanese_dialogue_quotes() -> anyhow::Result<()> {
         let mut block = TextBlock::default();
-        block.set_translation("「quoted」".to_string())?;
-        assert_eq!(block.translation.as_deref(), Some("「quoted」"));
+        block.set_translation("\u{300c}quoted\u{300d}".to_string())?;
+        assert_eq!(block.translation.as_deref(), Some("\u{300c}quoted\u{300d}"));
         Ok(())
     }
+
+    #[test]
+    fn parse_block_tag_parses_valid_tags() {
+        assert_eq!(parse_block_tag("<|1|>"), Some((5, 0)));
+        assert_eq!(parse_block_tag("<|2|>"), Some((5, 1)));
+        assert_eq!(parse_block_tag("<|10|>"), Some((6, 9)));
+    }
+
+    #[test]
+    fn parse_block_tag_rejects_invalid_tags() {
+        assert_eq!(parse_block_tag("<|0|>"), None);
+        assert_eq!(parse_block_tag("<|abc|>"), None);
+        assert_eq!(parse_block_tag("<block>"), None);
+        assert_eq!(parse_block_tag("hello"), None);
+    }
 }

koharu-app/src/renderer.rs

@@ -153,17 +153,25 @@ impl Renderer {
             .fontbook
             .lock()
             .map_err(|_| anyhow::anyhow!("Failed to lock fontbook"))?;
+        let mut seen = std::collections::HashSet::new();
         let mut fonts = fontbook
             .all_families()
             .into_iter()
             .filter(|face| !face.post_script_name.is_empty())
-            .map(|face| FontFaceInfo {
-                family_name: face
+            .filter_map(|face| {
+                let family_name = face
                     .families
                     .first()
                     .map(|(family, _)| family.clone())
-                    .unwrap_or_else(|| face.post_script_name.clone()),
-                post_script_name: face.post_script_name,
+                    .unwrap_or_else(|| face.post_script_name.clone());
+                if seen.insert(family_name.clone()) {
+                    Some(FontFaceInfo {
+                        family_name,
+                        post_script_name: face.post_script_name,
+                    })
+                } else {
+                    None
+                }
             })
             .collect::<Vec<_>>();
         fonts.sort();
@@ -201,6 +209,10 @@ impl Renderer {
             None => clustered_sizes,
         };
 
+        // Bubble expansion disabled — causes text to fly away from block position.
+        // Bubbles are used for font size estimation via detection, not layout.
+        let render_areas: Vec<Option<LayoutBox>> = vec![None; blocks_to_render.len()];
+
         let block_renders: Vec<Option<(DynamicImage, usize)>> = {
             use rayon::prelude::*;
             let span = tracing::info_span!("render_blocks", count = blocks_to_render.len());
@@ -212,12 +224,13 @@ impl Renderer {
                 .map(|(i, text_block)| {
                     let _guard = parent_span.enter();
                     let base_font_size = render_font_sizes.get(i).copied().flatten();
+                    let bubble_area = render_areas.get(i).copied().flatten();
                     match self.render_text_block(
                         text_block,
                         opts.shader_effect,
                         opts.shader_stroke.clone(),
                         opts.font_family,
-                        opts.bubbles,
+                        bubble_area,
                         base_font_size,
                         min_font,
                     ) {
@@ -256,12 +269,9 @@ impl Renderer {
                     continue;
                 };
                 let block_img = images.load(blob_ref)?;
-                imageops::overlay(
-                    &mut rendered,
-                    &block_img,
-                    text_block.x as i64,
-                    text_block.y as i64,
-                );
+                let rx = text_block.render_x.unwrap_or(text_block.x);
+                let ry = text_block.render_y.unwrap_or(text_block.y);
+                imageops::overlay(&mut rendered, &block_img, rx as i64, ry as i64);
             }
             let rendered_ref = images.store_raw(&DynamicImage::from(rendered))?;
             return Ok(Some(rendered_ref));
@@ -276,7 +286,7 @@ impl Renderer {
         effect: TextShaderEffect,
         global_stroke: Option<TextStrokeStyle>,
         font_family: Option<&str>,
-        bubbles: &[koharu_core::BubbleRegion],
+        bubble_area: Option<LayoutBox>,
         base_font_size: Option<f32>,
         min_font_size: f32,
     ) -> Result<Option<DynamicImage>> {
@@ -340,23 +350,16 @@ impl Renderer {
             }
         });
         let block_box = layout_box_from_block(&layout_source_block);
-        let bubble_box = find_best_bubble(text_block, bubbles);
-        // Use whichever is larger — bubble or text block box.
-        let layout_box = match bubble_box {
-            Some(bb) => LayoutBox {
-                x: block_box.x.min(bb.x),
-                y: block_box.y.min(bb.y),
-                width: block_box.width.max(bb.width),
-                height: block_box.height.max(bb.height),
-            },
-            None => block_box,
+        let (layout_box, bubble_expanded) = match bubble_area {
+            Some(area) => (area, true),
+            None => (block_box, false),
         };
 
-        // Determine base font size: user-set > clustered detected.
-        // If neither is available, skip rendering (no font size info).
-        let Some(effective_base_size) = style.font_size.or(base_font_size) else {
-            return Ok(None);
-        };
+        // Determine base font size: user-set > clustered detected > fallback.
+        let effective_base_size = style.font_size.or(base_font_size).unwrap_or_else(|| {
+            // Fallback: estimate from layout box height.
+            (layout_box.height * 0.3).clamp(min_font_size, 60.0)
+        });
 
         let layout_builder = TextLayout::new(&font, None)
             .with_fallback_fonts(&self.symbol_fallbacks)
@@ -383,6 +386,7 @@ impl Renderer {
             style.stroke.as_ref(),
             global_stroke.as_ref(),
             layout.font_size,
+            color,
         );
         let rendered = {
             let _s = tracing::info_span!("rasterize").entered();
@@ -399,14 +403,22 @@ impl Renderer {
             )?
         };
 
-        text_block.x = layout_box.x;
-        text_block.y = layout_box.y;
-        text_block.width = layout_box.width;
-        text_block.height = layout_box.height;
         text_block.rendered_direction = Some(match writing_mode {
             WritingMode::Horizontal => koharu_core::TextDirection::Horizontal,
             WritingMode::VerticalRl => koharu_core::TextDirection::Vertical,
         });
+        // Store actual render area when bubble expansion was used.
+        if bubble_expanded {
+            text_block.render_x = Some(layout_box.x.round());
+            text_block.render_y = Some(layout_box.y.round());
+            text_block.render_width = Some(layout_box.width.round());
+            text_block.render_height = Some(layout_box.height.round());
+        } else {
+            text_block.render_x = None;
+            text_block.render_y = None;
+            text_block.render_width = None;
+            text_block.render_height = None;
+        }
         // rendered field will be set by the caller with a BlobRef
         let persisted_style = text_block.style.get_or_insert_with(|| TextStyle {
             font_families: Vec::new(),
@@ -455,18 +467,41 @@ fn apply_default_font_families(font_families: &mut Vec<String>, text: &str) {
     }
 }
 
+fn colors_too_similar(a: [u8; 4], b: [u8; 4]) -> bool {
+    let dr = (a[0] as i32 - b[0] as i32).abs();
+    let dg = (a[1] as i32 - b[1] as i32).abs();
+    let db = (a[2] as i32 - b[2] as i32).abs();
+    dr + dg + db < 60
+}
+
+fn contrasting_stroke_color(text_color: [u8; 4]) -> [u8; 4] {
+    let luminance =
+        0.299 * text_color[0] as f32 + 0.587 * text_color[1] as f32 + 0.114 * text_color[2] as f32;
+    if luminance > 128.0 {
+        [0, 0, 0, 255]
+    } else {
+        [255, 255, 255, 255]
+    }
+}
+
 fn resolve_stroke_style(
     block: &TextBlock,
     block_stroke: Option<&TextStrokeStyle>,
     global_stroke: Option<&TextStrokeStyle>,
     font_size: f32,
+    text_color: [u8; 4],
 ) -> Option<RenderStrokeOptions> {
     if let Some(stroke) = block_stroke {
         if !stroke.enabled {
             return None;
         }
+        let color = if colors_too_similar(text_color, stroke.color) {
+            contrasting_stroke_color(text_color)
+        } else {
+            stroke.color
+        };
         return Some(RenderStrokeOptions {
-            color: stroke.color,
+            color,
             width_px: stroke
                 .width_px
                 .unwrap_or_else(|| default_stroke_width(font_size)),
@@ -477,8 +512,13 @@ fn resolve_stroke_style(
         if !stroke.enabled {
             return None;
         }
+        let color = if colors_too_similar(text_color, stroke.color) {
+            contrasting_stroke_color(text_color)
+        } else {
+            stroke.color
+        };
         return Some(RenderStrokeOptions {
-            color: stroke.color,
+            color,
             width_px: stroke
                 .width_px
                 .unwrap_or_else(|| default_stroke_width(font_size)),
@@ -488,19 +528,24 @@ fn resolve_stroke_style(
     if let Some(pred) = &block.font_prediction
         && pred.stroke_width_px > 0.0
     {
+        let pred_stroke = [
+            pred.stroke_color[0],
+            pred.stroke_color[1],
+            pred.stroke_color[2],
+            255,
+        ];
         return Some(RenderStrokeOptions {
-            color: [
-                pred.stroke_color[0],
-                pred.stroke_color[1],
-                pred.stroke_color[2],
-                255,
-            ],
+            color: if colors_too_similar(text_color, pred_stroke) {
+                contrasting_stroke_color(text_color)
+            } else {
+                pred_stroke
+            },
             width_px: pred.stroke_width_px,
         });
     }
 
     Some(RenderStrokeOptions {
-        color: [255, 255, 255, 255],
+        color: contrasting_stroke_color(text_color),
         width_px: default_stroke_width(font_size),
     })
 }
@@ -598,47 +643,88 @@ fn face_post_script_name(faces: &[FaceInfo], candidate: &str) -> Option<String>
         .filter(|post_script_name| !post_script_name.is_empty())
 }
 
-/// Find the bubble with the best IoU overlap for a text block.
-/// Returns the bubble's bbox as a LayoutBox if a good match is found.
+#[allow(dead_code)]
+fn compute_render_areas(
+    blocks: &[&mut TextBlock],
+    bubbles: &[koharu_core::BubbleRegion],
+) -> Vec<Option<LayoutBox>> {
+    // First pass: compute bubble-expanded area for each block.
+    let mut areas: Vec<Option<LayoutBox>> = blocks
+        .iter()
+        .map(|block| {
+            if block.lock_layout_box {
+                return None;
+            }
+            let bubble = find_best_bubble(block, bubbles)?;
+            let pad_x = bubble.width * 0.05;
+            let pad_y = bubble.height * 0.05;
+            Some(LayoutBox {
+                x: (bubble.x + pad_x).round(),
+                y: (bubble.y + pad_y).round(),
+                width: (bubble.width - pad_x * 2.0).round().max(1.0),
+                height: (bubble.height - pad_y * 2.0).round().max(1.0),
+            })
+        })
+        .collect();
+
+    // Second pass: if any two expanded areas overlap, fall back both to block dims.
+    for i in 0..areas.len() {
+        for j in (i + 1)..areas.len() {
+            let (Some(a), Some(b)) = (areas[i], areas[j]) else {
+                continue;
+            };
+            let overlap_x = (a.x + a.width).min(b.x + b.width) - a.x.max(b.x);
+            let overlap_y = (a.y + a.height).min(b.y + b.height) - a.y.max(b.y);
+            if overlap_x > 0.0 && overlap_y > 0.0 {
+                areas[i] = None;
+                areas[j] = None;
+                break;
+            }
+        }
+    }
+
+    areas
+}
+
+#[allow(dead_code)]
 fn find_best_bubble(block: &TextBlock, bubbles: &[koharu_core::BubbleRegion]) -> Option<LayoutBox> {
     if bubbles.is_empty() {
         return None;
     }
-
+    // Block center must be inside the bubble.
+    let cx = block.x + block.width * 0.5;
+    let cy = block.y + block.height * 0.5;
     let block_area = (block.width * block.height).max(1.0);
     let mut best: Option<(f32, &koharu_core::BubbleRegion)> = None;
-
     for bubble in bubbles {
+        // Check containment: block center inside bubble.
+        if cx < bubble.x
+            || cx > bubble.x + bubble.width
+            || cy < bubble.y
+            || cy > bubble.y + bubble.height
+        {
+            continue;
+        }
         let bubble_area = (bubble.width * bubble.height).max(1.0);
-
-        // Intersection
         let ix0 = block.x.max(bubble.x);
         let iy0 = block.y.max(bubble.y);
         let ix1 = (block.x + block.width).min(bubble.x + bubble.width);
         let iy1 = (block.y + block.height).min(bubble.y + bubble.height);
         let inter = (ix1 - ix0).max(0.0) * (iy1 - iy0).max(0.0);
-
-        // IoU
         let union = block_area + bubble_area - inter;
         let iou = if union > 0.0 { inter / union } else { 0.0 };
-
-        if let Some((best_iou, _)) = &best {
-            if iou > *best_iou {
-                best = Some((iou, bubble));
-            }
-        } else if iou > 0.0 {
-            best = Some((iou, bubble));
+        match &best {
+            Some((best_iou, _)) if iou > *best_iou => best = Some((iou, bubble)),
+            None if iou > 0.0 => best = Some((iou, bubble)),
+            _ => {}
         }
     }
-
-    // Require minimum overlap to avoid false matches
-    best.filter(|(iou, _)| *iou > 0.05)
-        .map(|(_, bubble)| LayoutBox {
-            x: bubble.x,
-            y: bubble.y,
-            width: bubble.width,
-            height: bubble.height,
-        })
+    best.filter(|(iou, _)| *iou > 0.1).map(|(_, b)| LayoutBox {
+        x: b.x,
+        y: b.y,
+        width: b.width,
+        height: b.height,
+    })
 }
 
 #[cfg(test)]

koharu-core/src/lib.rs

@@ -71,6 +71,16 @@ pub struct TextBlock {
     pub rendered: Option<BlobRef>,
     #[serde(default)]
     pub lock_layout_box: bool,
+    /// Actual render area — set by renderer when bubble expansion is used.
+    /// Frontend and composite use these for sprite positioning when present.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub render_x: Option<f32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub render_y: Option<f32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub render_width: Option<f32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub render_height: Option<f32>,
 }
 
 impl Default for TextBlock {
@@ -95,6 +105,10 @@ impl Default for TextBlock {
             font_prediction: None,
             rendered: None,
             lock_layout_box: false,
+            render_x: None,
+            render_y: None,
+            render_width: None,
+            render_height: None,
         }
     }
 }

koharu-core/src/protocol.rs

@@ -57,6 +57,15 @@ pub struct TextBlockDetail {
     /// Blob hash for the rendered text block sprite.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub rendered: Option<String>,
+    /// Actual render area position/size (when bubble expansion is used).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub render_x: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub render_y: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub render_width: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub render_height: Option<f32>,
 }
 
 impl From<&TextBlock> for TextBlockDetail {
@@ -80,6 +89,10 @@ impl From<&TextBlock> for TextBlockDetail {
             style: block.style.clone(),
             font_prediction: block.font_prediction.clone(),
             rendered: block.rendered.as_ref().map(|r| r.hash().to_string()),
+            render_x: block.render_x,
+            render_y: block.render_y,
+            render_width: block.render_width,
+            render_height: block.render_height,
         }
     }
 }

koharu-llm/src/prompt.rs

@@ -46,7 +46,7 @@ pub struct PromptRenderer {
     eos_token: String,
 }
 
-const BLOCK_TAG_INSTRUCTIONS: &str = "If the input contains <block id=\"N\">...</block>, translate only the text inside each block. Keep every block tag exactly unchanged, including ids, order, and block count. Do not merge blocks, split blocks, or add any text outside the blocks.";
+const BLOCK_TAG_INSTRUCTIONS: &str = "The input uses numbered tags like <|1|>, <|2|>, etc. to mark each text block. Translate only the text after each tag. Keep every tag exactly unchanged, including numbers and order. Output the same tags followed by the translated text. Do not merge, split, or reorder blocks.";
 
 pub fn system_prompt(target_language: Language) -> String {
     format!(
@@ -132,8 +132,8 @@ mod tests {
     fn system_prompt_mentions_target_language_and_block_rules() {
         let prompt = system_prompt(Language::Korean);
         assert!(prompt.contains("natural Korean"));
-        assert!(prompt.contains("<block id=\"N\">...</block>"));
-        assert!(prompt.contains("Do not merge blocks"));
+        assert!(prompt.contains("<|1|>, <|2|>"));
+        assert!(prompt.contains("Do not merge"));
     }
 
     #[test]

koharu-ml/src/comic_text_detector/mod.rs

@@ -3,11 +3,13 @@ mod postprocess;
 mod unet;
 mod yolo_v5;
 
-use std::{cmp, time::Instant};
+use std::cmp;
 
-use anyhow::Context;
+use anyhow::{Context, bail};
 use candle_core::{DType, Device, IndexOp, Tensor};
-use image::{DynamicImage, GenericImageView, GrayImage, RgbImage, imageops};
+use candle_transformers::object_detection::{Bbox, non_maximum_suppression};
+use image::{DynamicImage, GenericImageView, GrayImage};
+use koharu_core::TextBlock;
 use koharu_runtime::RuntimeManager;
 use tracing::instrument;
 
@@ -18,46 +20,34 @@ pub use postprocess::{
     refine_segmentation_mask,
 };
 
-const GPU_DETECT_SIZE: u32 = 1280;
-const CPU_DETECT_SIZE: u32 = 640;
-const DET_REARRANGE_MAX_BATCHES: usize = 4;
-const DET_REARRANGE_DOWNSCALE_THRESHOLD: f32 = 2.5;
-const DET_REARRANGE_ASPECT_THRESHOLD: f32 = 3.0;
-
-struct StitchBuffers<'a> {
-    shrink_sum: &'a mut [f32],
-    threshold_sum: &'a mut [f32],
-    mask_sum: &'a mut [f32],
-    counts: &'a mut [f32],
-}
-
-struct PatchPlacement {
-    width: u32,
-    height: u32,
-    offset_x: u32,
-    top: u32,
-    actual_height: u32,
-}
-
 const HF_REPO: &str = "mayocream/comic-text-detector";
+const CONFIDENCE_THRESHOLD: f32 = 0.4;
+const NMS_THRESHOLD: f32 = 0.35;
+const DBNET_BINARIZE_K: f64 = 50.0;
+const BINARY_THRESHOLD: u8 = 60;
+const DILATION_RADIUS: u32 = 3;
+const HOLE_CLOSE_RADIUS: u32 = 10;
+const BBOX_DILATION: f32 = 1.0;
+const GPU_DETECT_SIZE: u32 = 1024;
+const CPU_DETECT_SIZE: u32 = 640;
 
 koharu_runtime::declare_hf_model_package!(
     id: "model:comic-text-detector:yolo-v5",
-    repo: "mayocream/comic-text-detector",
+    repo: HF_REPO,
     file: "yolo-v5.safetensors",
     bootstrap: true,
     order: 110,
 );
 koharu_runtime::declare_hf_model_package!(
     id: "model:comic-text-detector:unet",
-    repo: "mayocream/comic-text-detector",
+    repo: HF_REPO,
     file: "unet.safetensors",
     bootstrap: true,
     order: 111,
 );
 koharu_runtime::declare_hf_model_package!(
     id: "model:comic-text-detector:dbnet",
-    repo: "mayocream/comic-text-detector",
+    repo: HF_REPO,
     file: "dbnet.safetensors",
     bootstrap: true,
     order: 112,
@@ -122,365 +112,90 @@ impl ComicTextDetector {
 
     #[instrument(level = "debug", skip_all)]
     pub fn inference(&self, image: &DynamicImage) -> anyhow::Result<ComicTextDetection> {
-        let detect_size = self.detect_size();
-        let maps = if let Some(maps) =
-            self.try_rearranged_maps(image, detect_size, DET_REARRANGE_MAX_BATCHES)?
-        {
-            maps
-        } else {
-            let original_dimensions = image.dimensions();
-            let (image_tensor, resized_dimensions) = preprocess(image, &self.device, detect_size)?;
-            let (mask, shrink_threshold) = self.forward(&image_tensor)?;
-            postprocess_maps(
-                &mask,
-                &shrink_threshold,
-                original_dimensions,
-                resized_dimensions,
-            )?
-        };
+        let original_dimensions = image.dimensions();
+        let (image_tensor, resized_dimensions) = preprocess(image, &self.device)?;
+        let (predictions, mask, shrink_threshold) = self.forward(&image_tensor)?;
+
+        let bboxes = postprocess_yolo(&predictions, original_dimensions, resized_dimensions)?;
+        let shrink_map = tensor_channel_to_gray_resized(
+            &shrink_threshold.i((0, 0))?,
+            original_dimensions.0,
+            original_dimensions.1,
+        )?;
+        let threshold_map = tensor_channel_to_gray_resized(
+            &shrink_threshold.i((0, 1))?,
+            original_dimensions.0,
+            original_dimensions.1,
+        )?;
+        let mask = postprocess_mask(
+            &mask,
+            &shrink_threshold,
+            original_dimensions,
+            resized_dimensions,
+        )?;
 
-        postprocess::build_detection(image, maps)
+        Ok(ComicTextDetection {
+            shrink_map,
+            threshold_map,
+            line_polygons: Vec::new(),
+            text_blocks: bboxes_to_text_blocks(bboxes),
+            mask,
+        })
     }
 
     #[instrument(level = "debug", skip_all)]
     pub fn inference_segmentation(&self, image: &DynamicImage) -> anyhow::Result<GrayImage> {
-        let started = Instant::now();
-        let detect_size = self.detect_size();
-        let (mask_map, rearranged) = if let Some(mask_map) =
-            self.try_rearranged_mask_map(image, detect_size, DET_REARRANGE_MAX_BATCHES)?
-        {
-            (mask_map, true)
-        } else {
-            let original_dimensions = image.dimensions();
-            let (image_tensor, resized_dimensions) = preprocess(image, &self.device, detect_size)?;
-            let mask = self.forward_mask(&image_tensor)?;
-            (
-                postprocess_mask(&mask, original_dimensions, resized_dimensions)?,
-                false,
-            )
-        };
-
-        tracing::info!(
-            width = image.width(),
-            height = image.height(),
-            rearranged,
-            total_ms = started.elapsed().as_millis(),
-            "comic text detector segmentation timings"
-        );
-
-        Ok(mask_map)
+        let original_dimensions = image.dimensions();
+        let (image_tensor, resized_dimensions) = preprocess(image, &self.device)?;
+        let mask = self.forward_mask(&image_tensor)?;
+        postprocess_unet_mask(&mask, original_dimensions, resized_dimensions)
     }
 
     #[instrument(level = "debug", skip_all)]
-    fn forward(&self, image: &Tensor) -> anyhow::Result<(Tensor, Tensor)> {
-        let (mask, features) = self.forward_yolo_unet(image)?;
+    fn forward(&self, image: &Tensor) -> anyhow::Result<(Tensor, Tensor, Tensor)> {
+        let (predictions, features) = self.yolo.forward(image)?;
+        let (mask, features) = self.unet.forward(
+            &features[0],
+            &features[1],
+            &features[2],
+            &features[3],
+            &features[4],
+        )?;
         let dbnet = self
             .dbnet
             .as_ref()
             .context("DBNet not loaded; use ComicTextDetector::load for full detection")?;
         let shrink_thresh = dbnet.forward(&features[0], &features[1], &features[2])?;
 
-        Ok((mask, shrink_thresh))
+        Ok((predictions, mask, shrink_thresh))
     }
 
     #[instrument(level = "debug", skip_all)]
     fn forward_mask(&self, image: &Tensor) -> anyhow::Result<Tensor> {
-        let (mask, _features) = self.forward_yolo_unet(image)?;
-        Ok(mask)
-    }
-
-    #[instrument(level = "debug", skip_all)]
-    fn forward_yolo_unet(&self, image: &Tensor) -> anyhow::Result<(Tensor, [Tensor; 3])> {
         let (_, features) = self.yolo.forward(image)?;
-        let (mask, features) = self.unet.forward(
+        let (mask, _) = self.unet.forward(
             &features[0],
             &features[1],
             &features[2],
             &features[3],
             &features[4],
         )?;
-        Ok((mask, features))
-    }
-
-    fn detect_size(&self) -> u32 {
-        match self.device {
-            Device::Cpu => CPU_DETECT_SIZE,
-            _ => GPU_DETECT_SIZE,
-        }
-    }
-
-    fn try_rearranged_maps(
-        &self,
-        image: &DynamicImage,
-        detect_size: u32,
-        max_batch_size: usize,
-    ) -> anyhow::Result<Option<postprocess::DetectionMaps>> {
-        let Some(layout) = build_rearranged_layout(image, detect_size) else {
-            return Ok(None);
-        };
-        let RearrangedLayout {
-            transpose,
-            width,
-            height,
-            pw_num,
-            metadata,
-            composites,
-            composite_size,
-        } = layout;
-
-        let pixel_count = (width * height) as usize;
-        let mut shrink_sum = vec![0.0f32; pixel_count];
-        let mut threshold_sum = vec![0.0f32; pixel_count];
-        let mut mask_sum = vec![0.0f32; pixel_count];
-        let mut counts = vec![0.0f32; pixel_count];
-
-        for batch_start in (0..composites.len()).step_by(max_batch_size.max(1)) {
-            let batch_end = (batch_start + max_batch_size).min(composites.len());
-            let mut tensors = Vec::with_capacity(batch_end - batch_start);
-            for composite in &composites[batch_start..batch_end] {
-                tensors.push(preprocess_rgb_image(composite, &self.device, detect_size)?);
-            }
-            let refs: Vec<&Tensor> = tensors.iter().collect();
-            let batch = Tensor::cat(&refs, 0)?;
-            let (mask_batch, shrink_threshold_batch) = self.forward(&batch)?;
-
-            for batch_index in 0..(batch_end - batch_start) {
-                let mask_map = tensor_channel_to_score_map_resized(
-                    &mask_batch.i((batch_index, 0))?,
-                    composite_size,
-                    composite_size,
-                )?;
-                let shrink_map = tensor_channel_to_score_map_resized(
-                    &shrink_threshold_batch.i((batch_index, 0))?,
-                    composite_size,
-                    composite_size,
-                )?;
-                let threshold_map = tensor_channel_to_score_map_resized(
-                    &shrink_threshold_batch.i((batch_index, 1))?,
-                    composite_size,
-                    composite_size,
-                )?;
-
-                for slot in 0..pw_num as usize {
-                    let patch_index = (batch_start + batch_index) * pw_num as usize + slot;
-                    if patch_index >= metadata.len() {
-                        break;
-                    }
-                    let (top, actual_height) = metadata[patch_index];
-                    if actual_height == 0 {
-                        continue;
-                    }
-
-                    let offset_x = slot as u32 * width;
-                    stitch_patch(
-                        StitchBuffers {
-                            shrink_sum: &mut shrink_sum,
-                            threshold_sum: &mut threshold_sum,
-                            mask_sum: &mut mask_sum,
-                            counts: &mut counts,
-                        },
-                        &shrink_map,
-                        &threshold_map,
-                        &mask_map,
-                        PatchPlacement {
-                            width,
-                            height,
-                            offset_x,
-                            top,
-                            actual_height,
-                        },
-                    );
-                }
-            }
-        }
-
-        let mut raw_shrink_map = accumulate_to_score_map(width, height, &shrink_sum, &counts);
-        let mut raw_threshold_map = accumulate_to_score_map(width, height, &threshold_sum, &counts);
-        let mut mask_map = accumulate_to_gray_image(width, height, &mask_sum, &counts)?;
-
-        if transpose {
-            raw_shrink_map = transpose_score_map(&raw_shrink_map);
-            raw_threshold_map = transpose_score_map(&raw_threshold_map);
-            mask_map = transpose_gray_image(&mask_map);
-        }
-
-        Ok(Some(postprocess::DetectionMaps {
-            shrink_map: score_map_to_gray_image(&raw_shrink_map)?,
-            threshold_map: score_map_to_gray_image(&raw_threshold_map)?,
-            raw_shrink_map,
-            raw_threshold_map,
-            mask_map,
-        }))
-    }
-
-    fn try_rearranged_mask_map(
-        &self,
-        image: &DynamicImage,
-        detect_size: u32,
-        max_batch_size: usize,
-    ) -> anyhow::Result<Option<GrayImage>> {
-        let Some(layout) = build_rearranged_layout(image, detect_size) else {
-            return Ok(None);
-        };
-        let RearrangedLayout {
-            transpose,
-            width,
-            height,
-            pw_num,
-            metadata,
-            composites,
-            composite_size,
-        } = layout;
-
-        let pixel_count = (width * height) as usize;
-        let mut mask_sum = vec![0.0f32; pixel_count];
-        let mut counts = vec![0.0f32; pixel_count];
-
-        for batch_start in (0..composites.len()).step_by(max_batch_size.max(1)) {
-            let batch_end = (batch_start + max_batch_size).min(composites.len());
-            let mut tensors = Vec::with_capacity(batch_end - batch_start);
-            for composite in &composites[batch_start..batch_end] {
-                tensors.push(preprocess_rgb_image(composite, &self.device, detect_size)?);
-            }
-            let refs: Vec<&Tensor> = tensors.iter().collect();
-            let batch = Tensor::cat(&refs, 0)?;
-            let mask_batch = self.forward_mask(&batch)?;
-
-            for batch_index in 0..(batch_end - batch_start) {
-                let mask_map = tensor_channel_to_score_map_resized(
-                    &mask_batch.i((batch_index, 0))?,
-                    composite_size,
-                    composite_size,
-                )?;
-
-                for slot in 0..pw_num as usize {
-                    let patch_index = (batch_start + batch_index) * pw_num as usize + slot;
-                    if patch_index >= metadata.len() {
-                        break;
-                    }
-                    let (top, actual_height) = metadata[patch_index];
-                    if actual_height == 0 {
-                        continue;
-                    }
-
-                    let offset_x = slot as u32 * width;
-                    stitch_mask_patch(
-                        &mut mask_sum,
-                        &mut counts,
-                        &mask_map,
-                        PatchPlacement {
-                            width,
-                            height,
-                            offset_x,
-                            top,
-                            actual_height,
-                        },
-                    );
-                }
-            }
-        }
-
-        let mut mask_map = accumulate_to_gray_image(width, height, &mask_sum, &counts)?;
-        if transpose {
-            mask_map = transpose_gray_image(&mask_map);
-        }
-        Ok(Some(mask_map))
-    }
-}
-
-struct RearrangedLayout {
-    transpose: bool,
-    width: u32,
-    height: u32,
-    pw_num: u32,
-    metadata: Vec<(u32, u32)>,
-    composites: Vec<RgbImage>,
-    composite_size: u32,
-}
-
-fn build_rearranged_layout(image: &DynamicImage, detect_size: u32) -> Option<RearrangedLayout> {
-    let mut working = image.to_rgb8();
-    let mut transpose = false;
-    let (mut height, mut width) = working.dimensions();
-    if height < width {
-        transpose = true;
-        working = transpose_rgb_image(&working);
-        (width, height) = working.dimensions();
-    }
-
-    let aspect_ratio = height as f32 / width as f32;
-    let down_scale_ratio = height as f32 / detect_size as f32;
-    let require_rearrange = down_scale_ratio > DET_REARRANGE_DOWNSCALE_THRESHOLD
-        && aspect_ratio > DET_REARRANGE_ASPECT_THRESHOLD;
-    if !require_rearrange {
-        return None;
-    }
-
-    let pw_num = (((2 * detect_size) as f32 / width as f32).floor() as u32).max(2);
-    let patch_height = pw_num * width;
-    let patch_count = height.div_ceil(patch_height);
-    let patch_step = if patch_count > 1 {
-        (height - patch_height) / (patch_count - 1)
-    } else {
-        0
-    };
-
-    let mut patches = Vec::new();
-    let mut metadata = Vec::new();
-    for index in 0..patch_count {
-        let top = index * patch_step;
-        let bottom = (top + patch_height).min(height);
-        let actual_height = bottom.saturating_sub(top);
-        let crop = imageops::crop_imm(&working, 0, top, width, actual_height).to_image();
-        let mut padded = RgbImage::from_pixel(width, patch_height, image::Rgb([0, 0, 0]));
-        imageops::replace(&mut padded, &crop, 0, 0);
-        patches.push(padded);
-        metadata.push((top, actual_height));
-    }
-
-    let composites_per_batch = (patch_count as usize).div_ceil(pw_num as usize);
-    let total_slots = composites_per_batch * pw_num as usize;
-    while patches.len() < total_slots {
-        patches.push(RgbImage::from_pixel(
-            width,
-            patch_height,
-            image::Rgb([0, 0, 0]),
-        ));
-        metadata.push((0, 0));
-    }
-
-    let composite_size = patch_height;
-    let mut composites = Vec::new();
-    for chunk in patches.chunks(pw_num as usize) {
-        let mut composite =
-            RgbImage::from_pixel(composite_size, composite_size, image::Rgb([0, 0, 0]));
-        for (slot, patch) in chunk.iter().enumerate() {
-            imageops::replace(&mut composite, patch, (slot as u32 * width) as i64, 0);
-        }
-        composites.push(composite);
+        Ok(mask)
     }
-
-    Some(RearrangedLayout {
-        transpose,
-        width,
-        height,
-        pw_num,
-        metadata,
-        composites,
-        composite_size,
-    })
 }
 
 #[instrument(level = "debug", skip_all)]
-fn preprocess(
-    image: &DynamicImage,
-    device: &Device,
-    image_size: u32,
-) -> anyhow::Result<(Tensor, (u32, u32))> {
+fn preprocess(image: &DynamicImage, device: &Device) -> anyhow::Result<(Tensor, (u32, u32))> {
     let (orig_w, orig_h) = image.dimensions();
-    let scale = (image_size as f32 / orig_w as f32).min(image_size as f32 / orig_h as f32);
-    let width = ((orig_w as f32 * scale).round() as u32).clamp(1, image_size);
-    let height = ((orig_h as f32 * scale).round() as u32).clamp(1, image_size);
+    let image_size = match device {
+        Device::Cpu => CPU_DETECT_SIZE,
+        _ => GPU_DETECT_SIZE,
+    };
+    let (width, height) = if orig_w >= orig_h {
+        (image_size, image_size * orig_h / orig_w)
+    } else {
+        (image_size * orig_w / orig_h, image_size)
+    };
     let (w, h) = (width as usize, height as usize);
     let tensor = (Tensor::from_vec(
         image.to_rgb8().into_raw(),
@@ -497,72 +212,111 @@ fn preprocess(
     Ok((tensor, (width, height)))
 }
 
-fn preprocess_rgb_image(
-    image: &RgbImage,
-    device: &Device,
-    image_size: u32,
-) -> anyhow::Result<Tensor> {
-    let resized = if image.width() == image_size && image.height() == image_size {
-        image.clone()
-    } else {
-        imageops::resize(
-            image,
-            image_size,
-            image_size,
-            imageops::FilterType::Triangle,
-        )
-    };
+#[instrument(level = "debug", skip(predictions))]
+fn postprocess_yolo(
+    predictions: &Tensor,
+    original_dimensions: (u32, u32),
+    resized_dimensions: (u32, u32),
+) -> anyhow::Result<Vec<Bbox<usize>>> {
+    let predictions = predictions.squeeze(0)?;
+    let (_, num_outputs) = predictions.dims2()?;
+    if num_outputs < 6 {
+        bail!("invalid prediction shape: expected at least 6 outputs, got {num_outputs}");
+    }
 
-    Ok((Tensor::from_vec(
-        resized.into_raw(),
-        (1, image_size as usize, image_size as usize, 3),
-        device,
-    )?
-    .permute((0, 3, 1, 2))?
-    .to_dtype(DType::F32)?
-        * (1. / 255.))?)
+    let num_classes = num_outputs - 5;
+    let (orig_w, orig_h) = original_dimensions;
+    let (resized_w, resized_h) = resized_dimensions;
+    let w_ratio = orig_w as f32 / resized_w as f32;
+    let h_ratio = orig_h as f32 / resized_h as f32;
+
+    let mut bboxes: Vec<Vec<Bbox<usize>>> = (0..num_classes).map(|_| Vec::new()).collect();
+    let predictions: Vec<Vec<f32>> = predictions.to_vec2()?;
+    for pred in predictions {
+        let (class_index, confidence) = {
+            let (cls_idx, cls_score) = pred[5..]
+                .iter()
+                .copied()
+                .enumerate()
+                .max_by(|a, b| a.1.total_cmp(&b.1))
+                .unwrap_or((0, 0.0));
+            (cls_idx, pred[4] * cls_score)
+        };
+        if confidence < CONFIDENCE_THRESHOLD {
+            continue;
+        }
+
+        let xmin = ((pred[0] - pred[2] / 2.) * w_ratio - BBOX_DILATION).clamp(0., orig_w as f32);
+        let xmax = ((pred[0] + pred[2] / 2.) * w_ratio + BBOX_DILATION).clamp(0., orig_w as f32);
+        let ymin = ((pred[1] - pred[3] / 2.) * h_ratio - BBOX_DILATION).clamp(0., orig_h as f32);
+        let ymax = ((pred[1] + pred[3] / 2.) * h_ratio + BBOX_DILATION).clamp(0., orig_h as f32);
+
+        bboxes[class_index].push(Bbox {
+            xmin,
+            xmax,
+            ymin,
+            ymax,
+            confidence,
+            data: class_index,
+        });
+    }
+
+    non_maximum_suppression(&mut bboxes, NMS_THRESHOLD);
+    Ok(bboxes.into_iter().flatten().collect())
 }
 
-fn postprocess_maps(
+#[instrument(level = "debug", skip(mask, shrink_thresh))]
+fn postprocess_mask(
     mask: &Tensor,
     shrink_thresh: &Tensor,
     original_dimensions: (u32, u32),
     resized_dimensions: (u32, u32),
-) -> anyhow::Result<postprocess::DetectionMaps> {
-    let shrink = shrink_thresh.i((0, 0))?;
-    let threshold = shrink_thresh.i((0, 1))?;
-    let unet_mask = mask.i((0, 0))?;
+) -> anyhow::Result<GrayImage> {
+    let shrink_and_thresh = shrink_thresh.squeeze(0)?;
+    let shrink = shrink_and_thresh.i(0)?;
+    let thresh = shrink_and_thresh.i(1)?;
+    let unet_mask = mask.squeeze(0)?;
 
-    let (db_h, db_w) = shrink.dims2()?;
-    let (mask_h, mask_w) = unet_mask.dims2()?;
-    let h = cmp::min(db_h, mask_h);
-    let w = cmp::min(db_w, mask_w);
-    let valid_h = h.min(resized_dimensions.1 as usize);
-    let valid_w = w.min(resized_dimensions.0 as usize);
+    let (_, h_db, w_db) = shrink_and_thresh.dims3()?;
+    let (_, h_unet, w_unet) = unet_mask.dims3()?;
+    let h = cmp::min(h_db, h_unet);
+    let w = cmp::min(w_db, w_unet);
 
-    let shrink = shrink.narrow(0, 0, valid_h)?.narrow(1, 0, valid_w)?;
-    let threshold = threshold.narrow(0, 0, valid_h)?.narrow(1, 0, valid_w)?;
-    let unet_mask = unet_mask.narrow(0, 0, valid_h)?.narrow(1, 0, valid_w)?;
+    let shrink = shrink.narrow(0, 0, h)?.narrow(1, 0, w)?;
+    let thresh = thresh.narrow(0, 0, h)?.narrow(1, 0, w)?;
+    let unet_mask = unet_mask.narrow(1, 0, h)?.narrow(2, 0, w)?.squeeze(0)?;
 
-    let raw_shrink_map = tensor_channel_to_score_map_exact(&shrink)?;
-    let raw_threshold_map = tensor_channel_to_score_map_exact(&threshold)?;
-    let shrink_map =
-        tensor_channel_to_gray_resized(&shrink, original_dimensions.0, original_dimensions.1)?;
-    let threshold_map =
-        tensor_channel_to_gray_resized(&threshold, original_dimensions.0, original_dimensions.1)?;
-    let mask_map =
-        tensor_channel_to_gray_resized(&unet_mask, original_dimensions.0, original_dimensions.1)?;
-
-    Ok(postprocess::DetectionMaps {
-        raw_shrink_map,
-        raw_threshold_map,
-        shrink_map,
-        threshold_map,
-        mask_map,
-    })
+    let prob = candle_nn::ops::sigmoid(&((&shrink - &thresh)? * DBNET_BINARIZE_K)?)?;
+    let fused = prob.maximum(&unet_mask)?;
+
+    let (mask_h, mask_w) = fused.dims2()?;
+    let valid_h = mask_h.min(resized_dimensions.1 as usize);
+    let valid_w = mask_w.min(resized_dimensions.0 as usize);
+
+    let fused = fused
+        .narrow(0, 0, valid_h)?
+        .narrow(1, 0, valid_w)?
+        .unsqueeze(0)?
+        .unsqueeze(0)?;
+
+    let resized = fused.interpolate2d(
+        original_dimensions.1 as usize,
+        original_dimensions.0 as usize,
+    )?;
+    let threshold = BINARY_THRESHOLD as f32 / 255.0;
+    let binary = resized.ge(threshold)?.to_dtype(DType::F32)?;
+
+    let closed = morph_close(&binary, HOLE_CLOSE_RADIUS as usize)?;
+    let dilated = dilate_tensor(&closed, DILATION_RADIUS as usize)?;
+    let mask = dilated.squeeze(0)?.squeeze(0)?;
+
+    let mask = (mask * 255.)?.to_dtype(DType::U8)?;
+    let data: Vec<u8> = mask.flatten_all()?.to_vec1()?;
+    GrayImage::from_raw(original_dimensions.0, original_dimensions.1, data)
+        .context("failed to build mask image")
 }
 
-fn postprocess_mask(
+fn postprocess_unet_mask(
     mask: &Tensor,
     original_dimensions: (u32, u32),
     resized_dimensions: (u32, u32),
@@ -580,88 +334,65 @@ fn tensor_channel_to_gray_resized(
     width: u32,
     height: u32,
 ) -> anyhow::Result<GrayImage> {
-    score_map_to_gray_image(&tensor_channel_to_score_map_resized(tensor, width, height)?)
+    let (th, tw) = tensor.dims2()?;
+    let values: Vec<f32> = tensor.to_device(&Device::Cpu)?.flatten_all()?.to_vec1()?;
+    let pixels: Vec<u8> = values
+        .iter()
+        .map(|&v| (v.clamp(0.0, 1.0) * 255.0).round() as u8)
+        .collect();
+    let small = GrayImage::from_raw(tw as u32, th as u32, pixels)
+        .context("failed to create gray image from tensor")?;
+    if tw as u32 == width && th as u32 == height {
+        return Ok(small);
+    }
+    Ok(image::imageops::resize(
+        &small,
+        width,
+        height,
+        image::imageops::FilterType::Nearest,
+    ))
 }
 
-fn tensor_channel_to_score_map_exact(tensor: &Tensor) -> anyhow::Result<postprocess::ScoreMap> {
-    let (height, width) = tensor.dims2()?;
-    let values: Vec<f32> = tensor.flatten_all()?.to_vec1()?;
-    Ok(postprocess::ScoreMap {
-        width: width as u32,
-        height: height as u32,
-        values,
-    })
+fn bboxes_to_text_blocks(mut bboxes: Vec<Bbox<usize>>) -> Vec<TextBlock> {
+    bboxes.sort_unstable_by(|a, b| {
+        let ay = a.ymin + (a.ymax - a.ymin) * 0.5;
+        let by = b.ymin + (b.ymax - b.ymin) * 0.5;
+        ay.partial_cmp(&by).unwrap_or(std::cmp::Ordering::Equal)
+    });
+
+    bboxes
+        .into_iter()
+        .map(|bbox| TextBlock {
+            x: bbox.xmin,
+            y: bbox.ymin,
+            width: bbox.xmax - bbox.xmin,
+            height: bbox.ymax - bbox.ymin,
+            confidence: bbox.confidence,
+            ..Default::default()
+        })
+        .collect()
 }
 
-fn tensor_channel_to_score_map_resized(
-    tensor: &Tensor,
-    width: u32,
-    height: u32,
-) -> anyhow::Result<postprocess::ScoreMap> {
-    let resized = tensor
-        .unsqueeze(0)?
-        .unsqueeze(0)?
-        .interpolate2d(height as usize, width as usize)?
-        .squeeze(0)?
-        .squeeze(0)?;
-    let values: Vec<f32> = resized.flatten_all()?.to_vec1()?;
-    Ok(postprocess::ScoreMap {
-        width,
-        height,
-        values,
-    })
+fn dilate_tensor(mask: &Tensor, radius: usize) -> anyhow::Result<Tensor> {
+    let kernel = 2 * radius + 1;
+    let padded = mask
+        .pad_with_zeros(2, radius, radius)?
+        .pad_with_zeros(3, radius, radius)?;
+    Ok(padded.max_pool2d_with_stride((kernel, kernel), (1, 1))?)
 }
 
-fn stitch_patch(
-    buffers: StitchBuffers<'_>,
-    shrink_map: &postprocess::ScoreMap,
-    threshold_map: &postprocess::ScoreMap,
-    mask_map: &postprocess::ScoreMap,
-    placement: PatchPlacement,
-) {
-    let PatchPlacement {
-        width,
-        height,
-        offset_x,
-        top,
-        actual_height,
-    } = placement;
-    for y in 0..actual_height.min(height.saturating_sub(top)) {
-        for x in 0..width {
-            let global_index = ((top + y) * width + x) as usize;
-            let source_x = offset_x + x;
-            buffers.shrink_sum[global_index] += shrink_map.get(source_x, y);
-            buffers.threshold_sum[global_index] += threshold_map.get(source_x, y);
-            buffers.mask_sum[global_index] += mask_map.get(source_x, y);
-            buffers.counts[global_index] += 1.0;
-        }
-    }
+fn erode_tensor(mask: &Tensor, radius: usize) -> anyhow::Result<Tensor> {
+    let inverted = (1.0 - mask)?;
+    let dilated = dilate_tensor(&inverted, radius)?;
+    Ok((1.0 - dilated)?)
 }
 
-fn stitch_mask_patch(
-    mask_sum: &mut [f32],
-    counts: &mut [f32],
-    mask_map: &postprocess::ScoreMap,
-    placement: PatchPlacement,
-) {
-    let PatchPlacement {
-        width,
-        height,
-        offset_x,
-        top,
-        actual_height,
-    } = placement;
-    for y in 0..actual_height.min(height.saturating_sub(top)) {
-        for x in 0..width {
-            let global_index = ((top + y) * width + x) as usize;
-            let source_x = offset_x + x;
-            mask_sum[global_index] += mask_map.get(source_x, y);
-            counts[global_index] += 1.0;
-        }
-    }
+fn morph_close(mask: &Tensor, radius: usize) -> anyhow::Result<Tensor> {
+    let dilated = dilate_tensor(mask, radius)?;
+    erode_tensor(&dilated, radius)
 }
 
-pub async fn prefetch_segmentation(runtime: &RuntimeManager) -> anyhow::Result<()> {
+pub async fn prefetch(runtime: &RuntimeManager) -> anyhow::Result<()> {
     let downloads = runtime.downloads();
     downloads
         .huggingface_model(HF_REPO, "yolo-v5.safetensors")
@@ -669,89 +400,19 @@ pub async fn prefetch_segmentation(runtime: &RuntimeManager) -> anyhow::Result<(
     downloads
         .huggingface_model(HF_REPO, "unet.safetensors")
         .await?;
+    downloads
+        .huggingface_model(HF_REPO, "dbnet.safetensors")
+        .await?;
     Ok(())
 }
 
-fn accumulate_to_score_map(
-    width: u32,
-    height: u32,
-    values: &[f32],
-    counts: &[f32],
-) -> postprocess::ScoreMap {
-    let values = values
-        .iter()
-        .zip(counts.iter())
-        .map(|(value, count)| {
-            if *count <= 0.0 {
-                0.0
-            } else {
-                (value / count).clamp(0.0, 1.0)
-            }
-        })
-        .collect();
-    postprocess::ScoreMap {
-        width,
-        height,
-        values,
-    }
-}
-
-fn accumulate_to_gray_image(
-    width: u32,
-    height: u32,
-    values: &[f32],
-    counts: &[f32],
-) -> anyhow::Result<GrayImage> {
-    score_map_to_gray_image(&accumulate_to_score_map(width, height, values, counts))
-}
-
-fn transpose_rgb_image(image: &RgbImage) -> RgbImage {
-    RgbImage::from_fn(image.height(), image.width(), |x, y| *image.get_pixel(y, x))
-}
-
-fn transpose_gray_image(image: &GrayImage) -> GrayImage {
-    GrayImage::from_fn(image.height(), image.width(), |x, y| *image.get_pixel(y, x))
-}
-
-fn transpose_score_map(score_map: &postprocess::ScoreMap) -> postprocess::ScoreMap {
-    let mut values = vec![0.0f32; (score_map.width * score_map.height) as usize];
-    for y in 0..score_map.height {
-        for x in 0..score_map.width {
-            values[(x * score_map.height + y) as usize] = score_map.get(x, y);
-        }
-    }
-    postprocess::ScoreMap {
-        width: score_map.height,
-        height: score_map.width,
-        values,
-    }
-}
-
-fn score_map_to_gray_image(score_map: &postprocess::ScoreMap) -> anyhow::Result<GrayImage> {
-    let bytes: Vec<u8> = score_map
-        .values
-        .iter()
-        .copied()
-        .map(float_to_byte)
-        .collect();
-    GrayImage::from_raw(score_map.width, score_map.height, bytes)
-        .context("failed to build CTD map image")
-}
-
-fn float_to_byte(value: f32) -> u8 {
-    (value.clamp(0.0, 1.0) * 255.0).round() as u8
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use image::Luma;
-
-    #[test]
-    fn transpose_helpers_round_trip() {
-        let image = GrayImage::from_fn(3, 5, |x, y| Luma([(x + y * 3) as u8]));
-        let transposed = transpose_gray_image(&image);
-        let round_trip = transpose_gray_image(&transposed);
-        assert_eq!(round_trip, image);
-    }
+pub async fn prefetch_segmentation(runtime: &RuntimeManager) -> anyhow::Result<()> {
+    let downloads = runtime.downloads();
+    downloads
+        .huggingface_model(HF_REPO, "yolo-v5.safetensors")
+        .await?;
+    downloads
+        .huggingface_model(HF_REPO, "unet.safetensors")
+        .await?;
+    Ok(())
 }

koharu-ml/src/comic_text_detector/postprocess.rs

@@ -3,21 +3,12 @@ use image::{
     imageops::{self},
 };
 use imageproc::{
-    contours::{BorderType as ContourBorderType, find_contours},
-    contrast::otsu_level,
     distance_transform::Norm,
-    drawing::draw_polygon_mut,
     geometric_transformations::{Interpolation, Projection, warp_into},
-    morphology::{dilate, erode},
-    point::Point,
-    region_labelling::{Connectivity, connected_components},
+    morphology::dilate,
 };
 use koharu_core::{TextBlock, TextDirection};
 
-const LINE_THRESHOLD: f32 = 0.3;
-const LINE_SCORE_THRESHOLD: f32 = 0.6;
-const MASK_SCORE_THRESHOLD: f32 = 0.1;
-const CTD_UNCLIP_RATIO: f32 = 1.5;
 const FINAL_MASK_DILATE_RADIUS: u8 = 2;
 
 pub type Quad = [[f32; 2]; 4];
@@ -31,190 +22,12 @@ pub struct ComicTextDetection {
     pub mask: GrayImage,
 }
 
-#[derive(Debug, Clone)]
-pub(crate) struct ScoreMap {
-    pub width: u32,
-    pub height: u32,
-    pub values: Vec<f32>,
-}
-
-impl ScoreMap {
-    pub(crate) fn get(&self, x: u32, y: u32) -> f32 {
-        self.values[(y * self.width + x) as usize]
-    }
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct DetectionMaps {
-    pub raw_shrink_map: ScoreMap,
-    pub raw_threshold_map: ScoreMap,
-    pub shrink_map: GrayImage,
-    pub threshold_map: GrayImage,
-    pub mask_map: GrayImage,
-}
-
-#[derive(Debug, Clone)]
-struct DetectedLine {
-    quad: Quad,
-    vertical: bool,
-    score: f32,
-}
-
-#[derive(Debug, Clone)]
-struct CtdBlock {
-    bbox: [f32; 4],
-    confidence: f32,
-    source_language: String,
-    source_direction: TextDirection,
-    lines: Vec<Quad>,
-    angle_deg: f32,
-    detected_font_size_px: f32,
-    distances: Vec<f32>,
-    direction_vec: [f32; 2],
-    direction_norm: f32,
-    merged: bool,
-}
-
-#[derive(Debug, Clone)]
-struct Component {
-    x: u32,
-    y: u32,
-    w: u32,
-    h: u32,
-    area: u32,
-    pixels: Vec<(u32, u32)>,
-}
-
-#[derive(Debug, Clone)]
-struct CandidateMask {
-    mask: GrayImage,
-    xor_sum: u64,
-}
-
-impl CtdBlock {
-    fn from_line(line: &DetectedLine) -> Self {
-        let bbox = quad_bbox(&line.quad);
-        Self {
-            bbox,
-            confidence: line.score,
-            source_language: "unknown".to_string(),
-            source_direction: if line.vertical {
-                TextDirection::Vertical
-            } else {
-                TextDirection::Horizontal
-            },
-            lines: vec![line.quad],
-            angle_deg: 0.0,
-            detected_font_size_px: 0.0,
-            distances: Vec::new(),
-            direction_vec: [1.0, 0.0],
-            direction_norm: 1.0,
-            merged: false,
-        }
-    }
-
-    fn center(&self) -> [f32; 2] {
-        [
-            (self.bbox[0] + self.bbox[2]) * 0.5,
-            (self.bbox[1] + self.bbox[3]) * 0.5,
-        ]
-    }
-
-    fn adjust_bbox(&mut self, with_bbox: bool) {
-        if self.lines.is_empty() {
-            return;
-        }
-
-        let mut min_x = f32::MAX;
-        let mut min_y = f32::MAX;
-        let mut max_x = f32::MIN;
-        let mut max_y = f32::MIN;
-        for line in &self.lines {
-            let bbox = quad_bbox(line);
-            min_x = min_x.min(bbox[0]);
-            min_y = min_y.min(bbox[1]);
-            max_x = max_x.max(bbox[2]);
-            max_y = max_y.max(bbox[3]);
-        }
-
-        if with_bbox {
-            self.bbox[0] = self.bbox[0].min(min_x);
-            self.bbox[1] = self.bbox[1].min(min_y);
-            self.bbox[2] = self.bbox[2].max(max_x);
-            self.bbox[3] = self.bbox[3].max(max_y);
-        } else {
-            self.bbox = [min_x, min_y, max_x, max_y];
-        }
-    }
-
-    fn sort_lines(&mut self) {
-        if self.distances.len() != self.lines.len() {
-            return;
-        }
-
-        let mut indexed: Vec<(f32, Quad)> = self
-            .distances
-            .iter()
-            .copied()
-            .zip(self.lines.iter().copied())
-            .collect();
-        indexed.sort_by(|a, b| a.0.total_cmp(&b.0));
-        self.distances = indexed.iter().map(|(distance, _)| *distance).collect();
-        self.lines = indexed.into_iter().map(|(_, line)| line).collect();
-    }
-}
-
-pub fn build_detection(
-    image: &DynamicImage,
-    maps: DetectionMaps,
-) -> anyhow::Result<ComicTextDetection> {
-    let DetectionMaps {
-        raw_shrink_map,
-        raw_threshold_map,
-        shrink_map,
-        threshold_map,
-        mask_map,
-    } = maps;
-    let scale_x = image.width() as f32 / raw_shrink_map.width.max(1) as f32;
-    let scale_y = image.height() as f32 / raw_shrink_map.height.max(1) as f32;
-    let detected_lines = extract_detected_lines(&raw_shrink_map, &raw_threshold_map)
-        .into_iter()
-        .map(|mut line| {
-            if (scale_x - 1.0).abs() > f32::EPSILON || (scale_y - 1.0).abs() > f32::EPSILON {
-                line.quad = scale_quad(&line.quad, scale_x, scale_y);
-            }
-            line
-        })
-        .collect::<Vec<_>>();
-    let line_polygons = detected_lines.iter().map(|line| line.quad).collect();
-    let text_blocks = group_output(&detected_lines, &mask_map, image.width(), image.height());
-    let mask = refine_segmentation_mask(image, &mask_map, &text_blocks);
-
-    Ok(ComicTextDetection {
-        shrink_map,
-        threshold_map,
-        line_polygons,
-        text_blocks,
-        mask,
-    })
-}
-
 pub fn refine_segmentation_mask(
-    image: &DynamicImage,
+    _image: &DynamicImage,
     pred_mask: &GrayImage,
-    blocks: &[TextBlock],
+    _blocks: &[TextBlock],
 ) -> GrayImage {
-    let base = if blocks.is_empty() {
-        threshold_binary(pred_mask, 60)
-    } else {
-        let refined = refine_mask(&image.to_rgb8(), pred_mask, blocks);
-        if refined.pixels().any(|pixel| pixel[0] > 0) {
-            refined
-        } else {
-            threshold_binary(pred_mask, 60)
-        }
-    };
-
+    let base = threshold_binary(pred_mask, 60);
     dilate(&base, Norm::L1, FINAL_MASK_DILATE_RADIUS)
 }
 
@@ -403,1541 +216,142 @@ fn maybe_expand_ctd_line(block: &TextBlock, line: &Quad) -> Quad {
     out
 }
 
-fn extract_detected_lines(shrink_map: &ScoreMap, _threshold_map: &ScoreMap) -> Vec<DetectedLine> {
-    let binary = GrayImage::from_fn(shrink_map.width, shrink_map.height, |x, y| {
-        let shrink_score = shrink_map.get(x, y);
-        if shrink_score > LINE_THRESHOLD {
-            Luma([255u8])
-        } else {
-            Luma([0u8])
-        }
-    });
-
-    let contours = find_contours::<i32>(&binary);
-    let mut lines = Vec::new();
-    for contour in contours {
-        if contour.border_type != ContourBorderType::Outer || contour.points.len() < 4 {
-            continue;
-        }
-
-        let contour_points = contour
-            .points
-            .into_iter()
-            .map(|point| [point.x as f32, point.y as f32])
-            .collect::<Vec<_>>();
-        let score = contour_score_fast(shrink_map, &contour_points);
-        if score < LINE_SCORE_THRESHOLD {
-            continue;
-        }
-
-        if let Some((quad, vertical)) = contour_quad(&contour_points) {
-            let (norm_v, norm_h) = quad_axis_lengths(&quad);
-            if norm_v.min(norm_h) < 2.0 {
-                continue;
-            }
-            lines.push(DetectedLine {
-                quad,
-                vertical,
-                score,
-            });
-        }
-    }
-
-    lines
-}
-
-#[cfg(test)]
-fn component_quad(component: &Component) -> Option<(Quad, bool)> {
-    if component.pixels.len() < 2 {
-        return None;
-    }
-
-    let mut mean_x = 0.0f32;
-    let mut mean_y = 0.0f32;
-    for (x, y) in &component.pixels {
-        mean_x += *x as f32;
-        mean_y += *y as f32;
-    }
-    let n = component.pixels.len() as f32;
-    mean_x /= n;
-    mean_y /= n;
-
-    let mut sxx = 0.0f32;
-    let mut syy = 0.0f32;
-    let mut sxy = 0.0f32;
-    for (x, y) in &component.pixels {
-        let dx = *x as f32 - mean_x;
-        let dy = *y as f32 - mean_y;
-        sxx += dx * dx;
-        syy += dy * dy;
-        sxy += dx * dy;
-    }
-    let angle = 0.5 * (2.0 * sxy).atan2(sxx - syy);
-    let ux = angle.cos();
-    let uy = angle.sin();
-    let vx = -uy;
-    let vy = ux;
-
-    let mut min_u = f32::MAX;
-    let mut max_u = f32::MIN;
-    let mut min_v = f32::MAX;
-    let mut max_v = f32::MIN;
-    for (x, y) in &component.pixels {
-        let dx = *x as f32 - mean_x;
-        let dy = *y as f32 - mean_y;
-        let u = dx * ux + dy * uy;
-        let v = dx * vx + dy * vy;
-        min_u = min_u.min(u);
-        max_u = max_u.max(u);
-        min_v = min_v.min(v);
-        max_v = max_v.max(v);
-    }
-
-    let width = (max_u - min_u).max(1.0);
-    let height = (max_v - min_v).max(1.0);
-    let perimeter = 2.0 * (width + height);
-    let offset = if perimeter > 0.0 {
-        (width * height * CTD_UNCLIP_RATIO) / perimeter
-    } else {
-        0.0
-    };
-    min_u -= offset;
-    max_u += offset;
-    min_v -= offset;
-    max_v += offset;
-
-    let quad = [
-        [
-            mean_x + ux * min_u + vx * min_v,
-            mean_y + uy * min_u + vy * min_v,
-        ],
-        [
-            mean_x + ux * max_u + vx * min_v,
-            mean_y + uy * max_u + vy * min_v,
-        ],
-        [
-            mean_x + ux * max_u + vx * max_v,
-            mean_y + uy * max_u + vy * max_v,
-        ],
-        [
-            mean_x + ux * min_u + vx * max_v,
-            mean_y + uy * min_u + vy * max_v,
-        ],
-    ];
-    let (quad, vertical) = sort_quad_points(&quad);
-    Some((quad, vertical))
-}
-
-fn contour_quad(points: &[[f32; 2]]) -> Option<(Quad, bool)> {
-    let quad = minimum_area_rect(points)?;
-    let area = polygon_area(&quad);
-    let perimeter = polygon_perimeter(&quad);
-    let offset = if perimeter > 0.0 {
-        (area * CTD_UNCLIP_RATIO) / perimeter
-    } else {
-        0.0
-    };
-    let expanded = expand_quad(&quad, offset);
-    let (quad, vertical) = sort_quad_points(&expanded);
-    Some((quad, vertical))
-}
-
-fn minimum_area_rect(points: &[[f32; 2]]) -> Option<Quad> {
-    let hull = convex_hull(points);
-    if hull.len() < 3 {
-        return None;
-    }
-
-    let mut best_area = f32::MAX;
-    let mut best_quad = None;
-    for index in 0..hull.len() {
-        let next = (index + 1) % hull.len();
-        let edge = [
-            hull[next][0] - hull[index][0],
-            hull[next][1] - hull[index][1],
-        ];
-        let edge_norm = vector_norm(edge);
-        if edge_norm <= 1e-6 {
-            continue;
-        }
-
-        let axis_u = [edge[0] / edge_norm, edge[1] / edge_norm];
-        let axis_v = [-axis_u[1], axis_u[0]];
-        let mut min_u = f32::MAX;
-        let mut max_u = f32::MIN;
-        let mut min_v = f32::MAX;
-        let mut max_v = f32::MIN;
-
-        for point in &hull {
-            let proj_u = dot(*point, axis_u);
-            let proj_v = dot(*point, axis_v);
-            min_u = min_u.min(proj_u);
-            max_u = max_u.max(proj_u);
-            min_v = min_v.min(proj_v);
-            max_v = max_v.max(proj_v);
-        }
-
-        let width = max_u - min_u;
-        let height = max_v - min_v;
-        let area = width * height;
-        if area >= best_area {
-            continue;
-        }
-
-        best_area = area;
-        best_quad = Some([
-            [
-                axis_u[0] * min_u + axis_v[0] * min_v,
-                axis_u[1] * min_u + axis_v[1] * min_v,
-            ],
-            [
-                axis_u[0] * max_u + axis_v[0] * min_v,
-                axis_u[1] * max_u + axis_v[1] * min_v,
-            ],
-            [
-                axis_u[0] * max_u + axis_v[0] * max_v,
-                axis_u[1] * max_u + axis_v[1] * max_v,
-            ],
-            [
-                axis_u[0] * min_u + axis_v[0] * max_v,
-                axis_u[1] * min_u + axis_v[1] * max_v,
-            ],
-        ]);
-    }
-
-    best_quad
-}
-
-fn expand_quad(quad: &Quad, offset: f32) -> Quad {
-    if offset <= 0.0 {
-        return *quad;
-    }
-
-    let axis_u = [quad[1][0] - quad[0][0], quad[1][1] - quad[0][1]];
-    let axis_v = [quad[3][0] - quad[0][0], quad[3][1] - quad[0][1]];
-    let norm_u = vector_norm(axis_u).max(1e-6);
-    let norm_v = vector_norm(axis_v).max(1e-6);
-    let unit_u = [axis_u[0] / norm_u, axis_u[1] / norm_u];
-    let unit_v = [axis_v[0] / norm_v, axis_v[1] / norm_v];
-    let signs = [[-1.0, -1.0], [1.0, -1.0], [1.0, 1.0], [-1.0, 1.0]];
-
-    let mut out = *quad;
-    for (index, point) in out.iter_mut().enumerate() {
-        point[0] += unit_u[0] * signs[index][0] * offset + unit_v[0] * signs[index][1] * offset;
-        point[1] += unit_u[1] * signs[index][0] * offset + unit_v[1] * signs[index][1] * offset;
-    }
-    out
-}
-
-fn convex_hull(points: &[[f32; 2]]) -> Vec<[f32; 2]> {
-    let mut points = points.to_vec();
-    points.sort_by(|a, b| a[0].total_cmp(&b[0]).then_with(|| a[1].total_cmp(&b[1])));
-    points.dedup_by(|a, b| (a[0] - b[0]).abs() < 1e-6 && (a[1] - b[1]).abs() < 1e-6);
-    if points.len() <= 2 {
-        return points;
-    }
-
-    let mut lower: Vec<[f32; 2]> = Vec::new();
-    for point in &points {
-        while lower.len() >= 2
-            && cross_2d(
-                [
-                    lower[lower.len() - 1][0] - lower[lower.len() - 2][0],
-                    lower[lower.len() - 1][1] - lower[lower.len() - 2][1],
-                ],
-                [
-                    point[0] - lower[lower.len() - 1][0],
-                    point[1] - lower[lower.len() - 1][1],
-                ],
-            ) <= 0.0
-        {
-            lower.pop();
-        }
-        lower.push(*point);
-    }
-
-    let mut upper: Vec<[f32; 2]> = Vec::new();
-    for point in points.iter().rev() {
-        while upper.len() >= 2
-            && cross_2d(
-                [
-                    upper[upper.len() - 1][0] - upper[upper.len() - 2][0],
-                    upper[upper.len() - 1][1] - upper[upper.len() - 2][1],
-                ],
-                [
-                    point[0] - upper[upper.len() - 1][0],
-                    point[1] - upper[upper.len() - 1][1],
-                ],
-            ) <= 0.0
-        {
-            upper.pop();
-        }
-        upper.push(*point);
-    }
-
-    lower.pop();
-    upper.pop();
-    lower.extend(upper);
-    lower
-}
-
-fn polygon_area(quad: &Quad) -> f32 {
-    let mut area = 0.0;
-    for index in 0..quad.len() {
-        let next = (index + 1) % quad.len();
-        area += quad[index][0] * quad[next][1] - quad[next][0] * quad[index][1];
-    }
-    area.abs() * 0.5
-}
-
-fn polygon_perimeter(quad: &Quad) -> f32 {
-    let mut perimeter = 0.0;
-    for index in 0..quad.len() {
-        let next = (index + 1) % quad.len();
-        perimeter += vector_norm([
-            quad[next][0] - quad[index][0],
-            quad[next][1] - quad[index][1],
-        ]);
+fn clip_quad(quad: &Quad, width: f32, height: f32) -> Quad {
+    let mut clipped = *quad;
+    for point in &mut clipped {
+        point[0] = point[0].clamp(0.0, width);
+        point[1] = point[1].clamp(0.0, height);
     }
-    perimeter
+    clipped
 }
 
-fn contour_score_fast(image: &ScoreMap, polygon: &[[f32; 2]]) -> f32 {
-    if polygon.is_empty() {
-        return 0.0;
-    }
-
+fn quad_bbox(quad: &Quad) -> [f32; 4] {
     let mut min_x = f32::MAX;
     let mut min_y = f32::MAX;
     let mut max_x = f32::MIN;
     let mut max_y = f32::MIN;
-    for point in polygon {
+    for point in quad {
         min_x = min_x.min(point[0]);
         min_y = min_y.min(point[1]);
         max_x = max_x.max(point[0]);
         max_y = max_y.max(point[1]);
     }
-
-    let x1 = min_x
-        .floor()
-        .clamp(0.0, image.width.saturating_sub(1) as f32) as u32;
-    let y1 = min_y
-        .floor()
-        .clamp(0.0, image.height.saturating_sub(1) as f32) as u32;
-    let x2 = max_x.ceil().clamp(x1 as f32 + 1.0, image.width as f32) as u32;
-    let y2 = max_y.ceil().clamp(y1 as f32 + 1.0, image.height as f32) as u32;
-
-    let mut mask = GrayImage::new(x2 - x1, y2 - y1);
-    let shifted = polygon
-        .iter()
-        .map(|point| {
-            Point::new(
-                (point[0] - x1 as f32).round() as i32,
-                (point[1] - y1 as f32).round() as i32,
-            )
-        })
-        .collect::<Vec<_>>();
-    draw_polygon_mut(&mut mask, &shifted, Luma([1u8]));
-
-    let mut sum = 0.0;
-    let mut count = 0.0;
-    for y in y1..y2 {
-        for x in x1..x2 {
-            if mask.get_pixel(x - x1, y - y1)[0] > 0 {
-                sum += image.get(x, y);
-                count += 1.0;
-            }
-        }
-    }
-
-    if count <= 0.0 { 0.0 } else { sum / count }
+    [min_x, min_y, max_x, max_y]
 }
 
-fn group_output(
-    lines: &[DetectedLine],
-    mask: &GrayImage,
-    image_width: u32,
-    image_height: u32,
-) -> Vec<TextBlock> {
-    let mut scattered_horizontal = Vec::new();
-    let mut scattered_vertical = Vec::new();
-
-    for line in lines {
-        let line_bbox = quad_bbox(&line.quad);
-        if mean_mask_score(mask, &line_bbox) >= MASK_SCORE_THRESHOLD {
-            let mut block = CtdBlock::from_line(line);
-            examine_block(&mut block, image_width, image_height, false);
-            if block.source_direction == TextDirection::Vertical {
-                scattered_vertical.push(block);
-            } else {
-                scattered_horizontal.push(block);
-            }
-        }
-    }
-
-    let mut final_blocks = Vec::new();
-    scattered_vertical.sort_by(|a, b| b.center()[0].total_cmp(&a.center()[0]));
-    scattered_horizontal.sort_by(|a, b| a.center()[1].total_cmp(&b.center()[1]));
-
-    final_blocks.extend(merge_text_lines(scattered_horizontal, 2.0));
-    final_blocks.extend(merge_text_lines(scattered_vertical, 1.7));
-    final_blocks = merge_paragraph_blocks(final_blocks, image_width, image_height);
-
-    let mut sorted = sort_regions(final_blocks);
-    dedupe_blocks(&mut sorted);
-    sorted.into_iter().map(block_to_text_block).collect()
+fn quad_to_tuples(quad: &Quad) -> [(f32, f32); 4] {
+    [
+        (quad[0][0], quad[0][1]),
+        (quad[1][0], quad[1][1]),
+        (quad[2][0], quad[2][1]),
+        (quad[3][0], quad[3][1]),
+    ]
 }
 
-fn block_to_text_block(block: CtdBlock) -> TextBlock {
-    let width = (block.bbox[2] - block.bbox[0]).max(1.0);
-    let height = (block.bbox[3] - block.bbox[1]).max(1.0);
-    TextBlock {
-        x: block.bbox[0],
-        y: block.bbox[1],
-        width,
-        height,
-        confidence: block.confidence,
-        line_polygons: Some(block.lines),
-        source_direction: Some(block.source_direction),
-        source_language: Some(block.source_language),
-        rotation_deg: Some(block.angle_deg),
-        detected_font_size_px: Some(block.detected_font_size_px.max(1.0)),
-        detector: Some("ctd".to_string()),
-        ..Default::default()
-    }
+fn quad_axis_lengths(quad: &Quad) -> (f32, f32) {
+    let midpoints = [
+        midpoint(quad[0], quad[1]),
+        midpoint(quad[1], quad[2]),
+        midpoint(quad[2], quad[3]),
+        midpoint(quad[3], quad[0]),
+    ];
+    let vec_v = [
+        midpoints[2][0] - midpoints[0][0],
+        midpoints[2][1] - midpoints[0][1],
+    ];
+    let vec_h = [
+        midpoints[1][0] - midpoints[3][0],
+        midpoints[1][1] - midpoints[3][1],
+    ];
+    (vector_norm(vec_v), vector_norm(vec_h))
 }
 
-fn examine_block(block: &mut CtdBlock, image_width: u32, image_height: u32, sort: bool) {
-    if block.lines.is_empty() {
-        block.detected_font_size_px = block.bbox_height().min(block.bbox_width()).max(1.0);
-        return;
-    }
-
-    let mut centers = Vec::with_capacity(block.lines.len());
-    let mut vec_v_sum = [0.0f32, 0.0f32];
-    let mut vec_h_sum = [0.0f32, 0.0f32];
-    let mut font_acc = 0.0f32;
-
-    for line in &block.lines {
-        let middle = quad_midpoints(line);
-        let vec_v = [middle[2][0] - middle[0][0], middle[2][1] - middle[0][1]];
-        let vec_h = [middle[1][0] - middle[3][0], middle[1][1] - middle[3][1]];
-        vec_v_sum[0] += vec_v[0];
-        vec_v_sum[1] += vec_v[1];
-        vec_h_sum[0] += vec_h[0];
-        vec_h_sum[1] += vec_h[1];
-        centers.push([
-            (line[0][0] + line[2][0]) * 0.5,
-            (line[0][1] + line[2][1]) * 0.5,
-        ]);
-        font_acc += match block.source_direction {
-            TextDirection::Vertical => vector_norm(vec_h),
-            TextDirection::Horizontal => vector_norm(vec_v),
-        };
-    }
-
-    let (primary_vec, primary_norm) = match block.source_direction {
-        TextDirection::Vertical => (vec_v_sum, vector_norm(vec_v_sum)),
-        TextDirection::Horizontal => (vec_h_sum, vector_norm(vec_h_sum)),
-    };
-
-    block.detected_font_size_px = (font_acc / block.lines.len() as f32).max(1.0);
-    block.direction_vec = primary_vec;
-    block.direction_norm = primary_norm.max(1.0);
-    block.distances = centers
-        .iter()
-        .map(|center| {
-            let origin = match block.source_direction {
-                TextDirection::Vertical => [image_width as f32, 0.0],
-                TextDirection::Horizontal => [0.0, 0.0],
-            };
-            perpendicular_distance(
-                [center[0] - origin[0], center[1] - origin[1]],
-                primary_vec,
-                image_height as f32,
-            )
-        })
-        .collect();
-
-    let mut angle = primary_vec[1].atan2(primary_vec[0]).to_degrees();
-    if block.source_direction == TextDirection::Vertical {
-        angle -= 90.0;
-    }
-    if angle.abs() < 3.0 {
-        angle = 0.0;
-    }
-    block.angle_deg = angle;
-    if sort {
-        block.sort_lines();
-    }
+fn midpoint(a: [f32; 2], b: [f32; 2]) -> [f32; 2] {
+    [(a[0] + b[0]) * 0.5, (a[1] + b[1]) * 0.5]
 }
 
-fn merge_text_lines(blocks: Vec<CtdBlock>, font_size_tol: f32) -> Vec<CtdBlock> {
-    if blocks.len() < 2 {
-        return blocks;
-    }
-
-    let mut blocks = blocks;
-    let mut merged = Vec::new();
-    for index in 0..blocks.len() {
-        if blocks[index].merged {
-            continue;
-        }
-        let mut current = blocks[index].clone();
-        for other in blocks.iter_mut().skip(index + 1) {
-            try_merge_text_line(&mut current, other, font_size_tol);
-        }
-        current.adjust_bbox(false);
-        merged.push(current);
-    }
-    merged
+fn vector_norm(vector: [f32; 2]) -> f32 {
+    (vector[0] * vector[0] + vector[1] * vector[1]).sqrt()
 }
 
-fn merge_paragraph_blocks(
-    blocks: Vec<CtdBlock>,
-    image_width: u32,
-    image_height: u32,
-) -> Vec<CtdBlock> {
-    if blocks.len() < 2 {
-        return blocks;
-    }
-
-    let mut blocks = sort_regions(blocks);
-    let mut merged = Vec::new();
-    for index in 0..blocks.len() {
-        if blocks[index].merged {
-            continue;
-        }
-        let mut current = blocks[index].clone();
-        while let Some(candidate_index) = find_paragraph_merge_candidate(&current, &blocks, index) {
-            let other = &mut blocks[candidate_index];
-            merge_paragraph_block(&mut current, other, image_width, image_height);
+fn threshold_binary(image: &GrayImage, threshold: u8) -> GrayImage {
+    GrayImage::from_fn(image.width(), image.height(), |x, y| {
+        if image.get_pixel(x, y)[0] > threshold {
+            Luma([255u8])
+        } else {
+            Luma([0u8])
         }
-        current.adjust_bbox(false);
-        merged.push(current);
-    }
-    merged
+    })
 }
 
-fn find_paragraph_merge_candidate(
-    current: &CtdBlock,
-    blocks: &[CtdBlock],
-    current_index: usize,
-) -> Option<usize> {
-    let mut best: Option<(usize, f32, f32)> = None;
-    for candidate_index in current_index + 1..blocks.len() {
-        let candidate = &blocks[candidate_index];
-        let Some(gap_y) = paragraph_merge_gap(current, candidate) else {
-            continue;
-        };
-        if paragraph_merge_blocked(current, candidate, blocks, current_index, candidate_index) {
-            continue;
-        }
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-        let overlap_x = horizontal_overlap(&current.bbox, &candidate.bbox);
-        match best {
-            Some((_, best_gap, best_overlap)) => {
-                if gap_y < best_gap - 1e-3
-                    || ((gap_y - best_gap).abs() <= 1e-3 && overlap_x > best_overlap)
-                {
-                    best = Some((candidate_index, gap_y, overlap_x));
-                }
+    #[test]
+    fn refine_segmentation_mask_thresholds_when_blocks_are_missing() {
+        let image = DynamicImage::ImageRgb8(RgbImage::from_pixel(16, 16, Rgb([255, 255, 255])));
+        let pred_mask = GrayImage::from_fn(16, 16, |x, y| {
+            if (4..12).contains(&x) && (5..11).contains(&y) {
+                Luma([200])
+            } else {
+                Luma([0])
             }
-            None => best = Some((candidate_index, gap_y, overlap_x)),
-        }
+        });
+
+        let mask = refine_segmentation_mask(&image, &pred_mask, &[]);
+        assert_eq!(mask.get_pixel(0, 0)[0], 0);
+        assert!(mask.get_pixel(8, 8)[0] > 0);
     }
 
-    best.map(|(index, _, _)| index)
-}
+    #[test]
+    fn refine_segmentation_mask_ignores_blocks() {
+        let image = DynamicImage::ImageRgb8(RgbImage::from_pixel(32, 32, Rgb([255, 255, 255])));
+        let pred_mask = GrayImage::from_fn(32, 32, |x, y| {
+            if (8..24).contains(&x) && (10..22).contains(&y) {
+                Luma([200])
+            } else {
+                Luma([0])
+            }
+        });
+        let block = TextBlock {
+            x: 10.0,
+            y: 11.0,
+            width: 8.0,
+            height: 6.0,
+            line_polygons: Some(vec![[
+                [10.0, 11.0],
+                [18.0, 11.0],
+                [18.0, 17.0],
+                [10.0, 17.0],
+            ]]),
+            source_direction: Some(TextDirection::Horizontal),
+            rotation_deg: Some(0.0),
+            detected_font_size_px: Some(6.0),
+            detector: Some("ctd".to_string()),
+            ..Default::default()
+        };
 
-fn paragraph_merge_gap(block: &CtdBlock, other: &CtdBlock) -> Option<f32> {
-    if other.merged
-        || block.source_direction != TextDirection::Horizontal
-        || other.source_direction != TextDirection::Horizontal
-        || block.lines.is_empty()
-        || other.lines.is_empty()
-    {
-        return None;
-    }
-
-    let count_a = block.lines.len() as f32;
-    let count_b = other.lines.len() as f32;
-    let font_avg = (block.detected_font_size_px * count_a + other.detected_font_size_px * count_b)
-        / (count_a + count_b).max(1.0);
-    if font_avg <= 0.0 {
-        return None;
-    }
-
-    let font_ratio = block.detected_font_size_px / other.detected_font_size_px.max(1e-6);
-    if font_ratio > 2.0 || font_ratio.recip() > 2.0 {
-        return None;
-    }
-
-    let (upper, lower) = if block.center()[1] <= other.center()[1] {
-        (block.bbox, other.bbox)
-    } else {
-        (other.bbox, block.bbox)
-    };
-    let gap_y = lower[1] - upper[3];
-    if gap_y < -font_avg * 0.25 || gap_y > font_avg * 0.9 {
-        return None;
-    }
-
-    let left_diff = (block.bbox[0] - other.bbox[0]).abs();
-    let right_diff = (block.bbox[2] - other.bbox[2]).abs();
-    let overlap_x = horizontal_overlap(&block.bbox, &other.bbox);
-    let width_similarity = overlap_x / block.bbox_width().min(other.bbox_width()).max(1.0);
-    let aligned_left = left_diff <= font_avg * 1.1;
-    let aligned_right = right_diff <= font_avg * 1.1;
-    let ragged_continue = left_diff <= font_avg * 1.8 && width_similarity >= 0.75;
-    if !(aligned_left || aligned_right || ragged_continue) {
-        return None;
-    }
-
-    let vec_prod = dot(block.direction_vec, other.direction_vec);
-    let cos_vec = vec_prod / (block.direction_norm * other.direction_norm).max(1e-6);
-    if cos_vec.abs() < 0.95 {
-        return None;
-    }
-
-    let angle_diff = (block.angle_deg - other.angle_deg).abs();
-    if angle_diff > 8.0 {
-        return None;
-    }
-
-    Some(gap_y.max(0.0))
-}
-
-fn paragraph_merge_blocked(
-    block: &CtdBlock,
-    other: &CtdBlock,
-    blocks: &[CtdBlock],
-    current_index: usize,
-    candidate_index: usize,
-) -> bool {
-    let column_left = block.bbox[0].max(other.bbox[0]);
-    let column_right = block.bbox[2].min(other.bbox[2]);
-    if column_right <= column_left {
-        return false;
-    }
-
-    let (upper, lower) = if block.center()[1] <= other.center()[1] {
-        (block.bbox, other.bbox)
-    } else {
-        (other.bbox, block.bbox)
-    };
-    let gap_top = upper[3];
-    let gap_bottom = lower[1];
-    if gap_bottom <= gap_top {
-        return false;
-    }
-
-    for (index, candidate) in blocks.iter().enumerate() {
-        if index == current_index || index == candidate_index || candidate.merged {
-            continue;
-        }
-        if candidate.source_direction != TextDirection::Horizontal {
-            continue;
-        }
-        if candidate.bbox[3] <= gap_top || candidate.bbox[1] >= gap_bottom {
-            continue;
-        }
-        let candidate_overlap =
-            (candidate.bbox[2].min(column_right) - candidate.bbox[0].max(column_left)).max(0.0);
-        if candidate_overlap > 0.0 {
-            return true;
-        }
-    }
-
-    false
-}
-
-fn merge_paragraph_block(
-    block: &mut CtdBlock,
-    other: &mut CtdBlock,
-    image_width: u32,
-    image_height: u32,
-) -> bool {
-    let Some(_) = paragraph_merge_gap(block, other) else {
-        return false;
-    };
-    let top = block.bbox[1].min(other.bbox[1]);
-    let bottom = block.bbox[3].max(other.bbox[3]);
-    let count_a = block.lines.len() as f32;
-    let count_b = other.lines.len() as f32;
-    let font_avg = (block.detected_font_size_px * count_a + other.detected_font_size_px * count_b)
-        / (count_a + count_b).max(1.0);
-
-    block.lines.extend(other.lines.iter().copied());
-    block.direction_vec = [
-        block.direction_vec[0] + other.direction_vec[0],
-        block.direction_vec[1] + other.direction_vec[1],
-    ];
-    block.direction_norm = vector_norm(block.direction_vec).max(1.0);
-    block.distances.extend(other.distances.iter().copied());
-    block.detected_font_size_px = font_avg.max(1.0);
-    block.confidence = block.confidence.max(other.confidence);
-    block.bbox = [
-        block.bbox[0].min(other.bbox[0]),
-        top,
-        block.bbox[2].max(other.bbox[2]),
-        bottom,
-    ];
-    other.merged = true;
-    examine_block(block, image_width, image_height, true);
-    true
-}
-
-fn try_merge_text_line(block: &mut CtdBlock, other: &mut CtdBlock, font_size_tol: f32) -> bool {
-    if other.merged || block.lines.is_empty() || other.lines.is_empty() {
-        return false;
-    }
-    if block.detected_font_size_px <= 0.0 || other.detected_font_size_px <= 0.0 {
-        return false;
-    }
-
-    let font_ratio = block.detected_font_size_px / other.detected_font_size_px;
-    let count_a = block.lines.len() as f32;
-    let count_b = other.lines.len() as f32;
-    let font_avg = (block.detected_font_size_px * count_a + other.detected_font_size_px * count_b)
-        / (count_a + count_b);
-    let vec_prod = dot(block.direction_vec, other.direction_vec);
-    let cos_vec = vec_prod / (block.direction_norm * other.direction_norm).max(1e-6);
-    let line_a = block.lines[block.lines.len() - 1];
-    let line_b = other.lines[0];
-    let bbox_a = quad_bbox(&line_a);
-    let bbox_b = quad_bbox(&line_b);
-    let distance_x = bbox_a[0].max(bbox_b[0]) - bbox_a[2].min(bbox_b[2]);
-    let distance_y = bbox_a[1].max(bbox_b[1]) - bbox_a[3].min(bbox_b[3]);
-    let w1 = (bbox_a[2] - bbox_a[0]).max(1.0);
-    let w2 = (bbox_b[2] - bbox_b[0]).max(1.0);
-    let h1 = (bbox_a[3] - bbox_a[1]).max(1.0);
-    let h2 = (bbox_b[3] - bbox_b[1]).max(1.0);
-
-    if !quads_intersect(&line_a, &line_b) {
-        match block.source_direction {
-            TextDirection::Vertical => {
-                if distance_y > 0.0 {
-                    return false;
-                }
-                if distance_x > font_avg * 0.8 {
-                    return false;
-                }
-                if distance_y.abs() / h1.min(h2) < 0.4 {
-                    return false;
-                }
-            }
-            TextDirection::Horizontal => {
-                if distance_x > 0.0 {
-                    return false;
-                }
-                let width_similarity = (w1.min(w2) / w1.max(w2)).clamp(0.0, 1.0);
-                let mut font_threshold = if font_avg < 24.0 { 0.6 } else { 0.5 };
-                if width_similarity > 0.95 {
-                    font_threshold -= 0.08;
-                } else if width_similarity < 0.88 {
-                    font_threshold += 0.1;
-                }
-                if distance_y > font_avg * font_threshold {
-                    return false;
-                }
-                if distance_x.abs() / w1.min(w2) < 0.3 {
-                    return false;
-                }
-            }
-        }
-
-        if font_ratio > font_size_tol || font_ratio.recip() > font_size_tol {
-            return false;
-        }
-        if cos_vec.abs() < 0.866 {
-            return false;
-        }
-    }
-
-    block.lines.extend(other.lines.iter().copied());
-    block.direction_vec = [
-        block.direction_vec[0] + other.direction_vec[0],
-        block.direction_vec[1] + other.direction_vec[1],
-    ];
-    block.direction_norm = vector_norm(block.direction_vec).max(1.0);
-    block.angle_deg = block.direction_vec[1]
-        .atan2(block.direction_vec[0])
-        .to_degrees();
-    if block.source_direction == TextDirection::Vertical {
-        block.angle_deg -= 90.0;
-    }
-    block.distances.extend(other.distances.iter().copied());
-    block.detected_font_size_px = font_avg.max(1.0);
-    block.confidence = block.confidence.max(other.confidence);
-    other.merged = true;
-    true
-}
-
-fn sort_regions(blocks: Vec<CtdBlock>) -> Vec<CtdBlock> {
-    if blocks.len() < 2 {
-        return blocks;
-    }
-
-    let vertical_blocks = blocks
-        .iter()
-        .filter(|block| block.source_direction == TextDirection::Vertical)
-        .count();
-    let right_to_left = !blocks.is_empty() && vertical_blocks * 2 >= blocks.len();
-    let order = stable_reading_order_indices(&blocks, right_to_left);
-    let mut ordered = Vec::with_capacity(blocks.len());
-    let mut slots = blocks.into_iter().map(Some).collect::<Vec<_>>();
-    for index in order {
-        if let Some(block) = slots[index].take() {
-            ordered.push(block);
-        }
-    }
-    ordered
-}
-
-fn compare_blocks_for_reading_order(
-    a: &CtdBlock,
-    b: &CtdBlock,
-    right_to_left: bool,
-) -> std::cmp::Ordering {
-    let overlap_y = vertical_overlap(&a.bbox, &b.bbox);
-    let row_tolerance = (a.detected_font_size_px.max(b.detected_font_size_px) * 0.6).max(1.0);
-    if overlap_y > 0.0 || (a.center()[1] - b.center()[1]).abs() <= row_tolerance {
-        if right_to_left {
-            b.center()[0]
-                .total_cmp(&a.center()[0])
-                .then_with(|| a.center()[1].total_cmp(&b.center()[1]))
-        } else {
-            a.center()[0]
-                .total_cmp(&b.center()[0])
-                .then_with(|| a.center()[1].total_cmp(&b.center()[1]))
-        }
-    } else {
-        a.center()[1]
-            .total_cmp(&b.center()[1])
-            .then_with(|| a.center()[0].total_cmp(&b.center()[0]))
-    }
-}
-
-fn stable_reading_order_indices(blocks: &[CtdBlock], right_to_left: bool) -> Vec<usize> {
-    let mut edges = vec![Vec::new(); blocks.len()];
-    let mut indegree = vec![0usize; blocks.len()];
-    for left in 0..blocks.len() {
-        for right in (left + 1)..blocks.len() {
-            match compare_blocks_for_reading_order(&blocks[left], &blocks[right], right_to_left) {
-                std::cmp::Ordering::Less => {
-                    edges[left].push(right);
-                    indegree[right] += 1;
-                }
-                std::cmp::Ordering::Greater => {
-                    edges[right].push(left);
-                    indegree[left] += 1;
-                }
-                std::cmp::Ordering::Equal => {}
-            }
-        }
-    }
-
-    let mut remaining = (0..blocks.len()).collect::<Vec<_>>();
-    let mut ordered = Vec::with_capacity(blocks.len());
-    while !remaining.is_empty() {
-        let available = remaining
-            .iter()
-            .copied()
-            .filter(|index| indegree[*index] == 0)
-            .collect::<Vec<_>>();
-        let next = available.first().copied().unwrap_or_else(|| remaining[0]);
-        ordered.push(next);
-        remaining.retain(|index| *index != next);
-        for successor in &edges[next] {
-            indegree[*successor] = indegree[*successor].saturating_sub(1);
-        }
-    }
-
-    ordered
-}
-fn dedupe_blocks(blocks: &mut Vec<CtdBlock>) {
-    if blocks.len() < 2 {
-        return;
-    }
-
-    let mut deduped = vec![blocks[0].clone()];
-    for block in blocks.iter().skip(1) {
-        let area = bbox_area(&block.bbox).max(1e-6);
-        let mut keep = true;
-        for existing in &deduped {
-            let intersection = overlap_area(&block.bbox, &existing.bbox);
-            if intersection / area > 0.9 {
-                keep = false;
-                break;
-            }
-        }
-        if keep {
-            deduped.push(block.clone());
-        }
-    }
-    *blocks = deduped;
-}
-
-fn refine_mask(image: &RgbImage, pred_mask: &GrayImage, blocks: &[TextBlock]) -> GrayImage {
-    let mut refined = GrayImage::new(pred_mask.width(), pred_mask.height());
-    for block in blocks {
-        let bbox = [
-            block.x,
-            block.y,
-            block.x + block.width,
-            block.y + block.height,
-        ];
-        let [x1f, y1f, x2f, y2f] =
-            enlarge_window(bbox, image.width() as f32, image.height() as f32);
-        if x2f <= x1f || y2f <= y1f {
-            continue;
-        }
-
-        let x1 = x1f as u32;
-        let y1 = y1f as u32;
-        let width = x2f as u32 - x1;
-        let height = y2f as u32 - y1;
-        let rgb_crop = imageops::crop_imm(image, x1, y1, width, height).to_image();
-        let mask_crop = imageops::crop_imm(pred_mask, x1, y1, width, height).to_image();
-        let mut candidates = topk_mask_candidates(&rgb_crop, &mask_crop);
-        candidates.extend(otsu_mask_candidates(&rgb_crop, &mask_crop));
-        let merged = merge_mask_candidates(candidates, &mask_crop);
-
-        for local_y in 0..height {
-            for local_x in 0..width {
-                if merged.get_pixel(local_x, local_y)[0] > 0 {
-                    refined.put_pixel(x1 + local_x, y1 + local_y, Luma([255]));
-                }
-            }
-        }
-    }
-    refined
-}
-
-fn topk_mask_candidates(image: &RgbImage, pred_mask: &GrayImage) -> Vec<CandidateMask> {
-    let eroded = erode(pred_mask, Norm::LInf, 1);
-    let gray = DynamicImage::ImageRgb8(image.clone())
-        .grayscale()
-        .to_luma8();
-    let mut histogram = [0u32; 256];
-    let mut total = 0u32;
-    for (pixel, mask_pixel) in gray.pixels().zip(eroded.pixels()) {
-        if mask_pixel[0] > 127 {
-            histogram[pixel[0] as usize] += 1;
-            total += 1;
-        }
-    }
-    if total == 0 {
-        return Vec::new();
-    }
-
-    let mut colors: Vec<(u8, u32)> = histogram
-        .iter()
-        .enumerate()
-        .filter_map(|(index, count)| {
-            if *count > 0 {
-                Some((index as u8, *count))
-            } else {
-                None
-            }
-        })
-        .collect();
-    colors.sort_by(|a, b| b.1.cmp(&a.1));
-
-    let mut top_colors = Vec::new();
-    let bin_tol = (total as f32 * 0.001).ceil() as u32;
-    for (color, count) in colors {
-        if top_colors
-            .iter()
-            .all(|existing: &u8| existing.abs_diff(color) > 10)
-        {
-            top_colors.push(color);
-        }
-        if top_colors.len() >= 3 || count < bin_tol {
-            break;
-        }
-    }
-
-    top_colors
-        .into_iter()
-        .map(|color| {
-            let top = color.saturating_add(30);
-            let bottom = color.saturating_sub(30);
-            let thresholded = GrayImage::from_fn(gray.width(), gray.height(), |x, y| {
-                let value = gray.get_pixel(x, y)[0];
-                if value >= bottom && value <= top {
-                    Luma([255u8])
-                } else {
-                    Luma([0u8])
-                }
-            });
-            minxor_threshold(thresholded, pred_mask)
-        })
-        .collect()
-}
-
-fn otsu_mask_candidates(image: &RgbImage, pred_mask: &GrayImage) -> Vec<CandidateMask> {
-    let mut candidates = Vec::new();
-    for channel in 0..3 {
-        let channel_image = GrayImage::from_fn(image.width(), image.height(), |x, y| {
-            Luma([image.get_pixel(x, y)[channel]])
-        });
-        let level = otsu_level(&channel_image);
-        let thresholded =
-            GrayImage::from_fn(channel_image.width(), channel_image.height(), |x, y| {
-                if channel_image.get_pixel(x, y)[0] > level {
-                    Luma([255u8])
-                } else {
-                    Luma([0u8])
-                }
-            });
-        candidates.push(minxor_threshold(thresholded, pred_mask));
-    }
-    candidates.sort_by(|a, b| a.xor_sum.cmp(&b.xor_sum));
-    candidates.into_iter().take(1).collect()
-}
-
-fn minxor_threshold(thresholded: GrayImage, pred_mask: &GrayImage) -> CandidateMask {
-    let inverted = invert_binary(&thresholded);
-    let regular_xor = xor_sum(&thresholded, pred_mask);
-    let inverted_xor = xor_sum(&inverted, pred_mask);
-    if inverted_xor < regular_xor {
-        CandidateMask {
-            mask: inverted,
-            xor_sum: inverted_xor,
-        }
-    } else {
-        CandidateMask {
-            mask: thresholded,
-            xor_sum: regular_xor,
-        }
-    }
-}
-
-fn merge_mask_candidates(mut candidates: Vec<CandidateMask>, pred_mask: &GrayImage) -> GrayImage {
-    candidates.sort_by(|a, b| a.xor_sum.cmp(&b.xor_sum));
-    let mut mask_merged = GrayImage::new(pred_mask.width(), pred_mask.height());
-    let pred = threshold_binary(&erode(pred_mask, Norm::LInf, 1), 60);
-
-    for candidate in candidates {
-        let components = connected_components_stats(&candidate.mask, Connectivity::Eight);
-        for component in components {
-            if component.w * component.h < 3 {
-                continue;
-            }
-
-            let current = imageops::crop_imm(
-                &mask_merged,
-                component.x,
-                component.y,
-                component.w,
-                component.h,
-            )
-            .to_image();
-            let mut combined = current.clone();
-            for (x, y) in &component.pixels {
-                combined.put_pixel(*x - component.x, *y - component.y, Luma([255]));
-            }
-
-            let pred_crop =
-                imageops::crop_imm(&pred, component.x, component.y, component.w, component.h)
-                    .to_image();
-            if xor_sum(&combined, &pred_crop) < xor_sum(&current, &pred_crop) {
-                for local_y in 0..component.h {
-                    for local_x in 0..component.w {
-                        let pixel = combined.get_pixel(local_x, local_y);
-                        if pixel[0] > 0 {
-                            mask_merged.put_pixel(
-                                component.x + local_x,
-                                component.y + local_y,
-                                *pixel,
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    let mut mask_merged = dilate(&mask_merged, Norm::LInf, 2);
-    let inverted = invert_binary(&mask_merged);
-    let holes = connected_components_stats(&inverted, Connectivity::Eight);
-    if !holes.is_empty() {
-        let mut areas: Vec<u32> = holes.iter().map(|component| component.area).collect();
-        areas.sort_unstable();
-        let area_threshold = if areas.len() > 1 {
-            areas[areas.len() - 2]
-        } else {
-            areas[0]
-        };
-
-        for component in holes {
-            if component.area >= area_threshold {
-                continue;
-            }
-
-            let current = imageops::crop_imm(
-                &mask_merged,
-                component.x,
-                component.y,
-                component.w,
-                component.h,
-            )
-            .to_image();
-            let mut combined = current.clone();
-            for (x, y) in &component.pixels {
-                combined.put_pixel(*x - component.x, *y - component.y, Luma([255]));
-            }
-            let pred_crop =
-                imageops::crop_imm(&pred, component.x, component.y, component.w, component.h)
-                    .to_image();
-            if xor_sum(&combined, &pred_crop) < xor_sum(&current, &pred_crop) {
-                for local_y in 0..component.h {
-                    for local_x in 0..component.w {
-                        let pixel = combined.get_pixel(local_x, local_y);
-                        if pixel[0] > 0 {
-                            mask_merged.put_pixel(
-                                component.x + local_x,
-                                component.y + local_y,
-                                *pixel,
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    mask_merged
-}
-
-fn connected_components_stats(image: &GrayImage, connectivity: Connectivity) -> Vec<Component> {
-    let labels = connected_components(image, connectivity, Luma([0u8]));
-    let max_label = labels.pixels().map(|pixel| pixel[0]).max().unwrap_or(0);
-    let mut components = vec![
-        Component {
-            x: 0,
-            y: 0,
-            w: 0,
-            h: 0,
-            area: 0,
-            pixels: Vec::new(),
-        };
-        (max_label + 1) as usize
-    ];
-
-    for component in components.iter_mut().skip(1) {
-        component.x = u32::MAX;
-        component.y = u32::MAX;
-    }
-
-    for y in 0..labels.height() {
-        for x in 0..labels.width() {
-            let label = labels.get_pixel(x, y)[0];
-            if label == 0 {
-                continue;
-            }
-            let component = &mut components[label as usize];
-            component.area += 1;
-            component.x = component.x.min(x);
-            component.y = component.y.min(y);
-            component.w = component.w.max(x);
-            component.h = component.h.max(y);
-            component.pixels.push((x, y));
-        }
-    }
-
-    for component in components.iter_mut().skip(1) {
-        if component.pixels.is_empty() {
-            continue;
-        }
-        component.w = component.w.saturating_sub(component.x) + 1;
-        component.h = component.h.saturating_sub(component.y) + 1;
-    }
-
-    components
-        .into_iter()
-        .skip(1)
-        .filter(|component| component.area > 0)
-        .collect()
-}
-
-fn quad_midpoints(quad: &Quad) -> Quad {
-    [
-        midpoint(quad[0], quad[1]),
-        midpoint(quad[1], quad[2]),
-        midpoint(quad[2], quad[3]),
-        midpoint(quad[3], quad[0]),
-    ]
-}
-
-fn quad_axis_lengths(quad: &Quad) -> (f32, f32) {
-    let midpoints = quad_midpoints(quad);
-    let vec_v = [
-        midpoints[2][0] - midpoints[0][0],
-        midpoints[2][1] - midpoints[0][1],
-    ];
-    let vec_h = [
-        midpoints[1][0] - midpoints[3][0],
-        midpoints[1][1] - midpoints[3][1],
-    ];
-    (vector_norm(vec_v), vector_norm(vec_h))
-}
-
-fn midpoint(a: [f32; 2], b: [f32; 2]) -> [f32; 2] {
-    [(a[0] + b[0]) * 0.5, (a[1] + b[1]) * 0.5]
-}
-
-fn quad_to_tuples(quad: &Quad) -> [(f32, f32); 4] {
-    [
-        (quad[0][0], quad[0][1]),
-        (quad[1][0], quad[1][1]),
-        (quad[2][0], quad[2][1]),
-        (quad[3][0], quad[3][1]),
-    ]
-}
-
-fn reorder_quad_horizontal(quad: &Quad) -> Quad {
-    let mut points = *quad;
-    points.sort_by(|a, b| a[0].total_cmp(&b[0]).then_with(|| a[1].total_cmp(&b[1])));
-    let mut left = [points[0], points[1]];
-    let mut right = [points[2], points[3]];
-    left.sort_by(|a, b| a[1].total_cmp(&b[1]));
-    right.sort_by(|a, b| a[1].total_cmp(&b[1]));
-    [left[0], right[0], right[1], left[1]]
-}
-
-fn reorder_quad_vertical(quad: &Quad) -> Quad {
-    let mut points = *quad;
-    points.sort_by(|a, b| a[1].total_cmp(&b[1]).then_with(|| a[0].total_cmp(&b[0])));
-    let mut top = [points[0], points[1]];
-    let mut bottom = [points[2], points[3]];
-    top.sort_by(|a, b| a[0].total_cmp(&b[0]));
-    bottom.sort_by(|a, b| b[0].total_cmp(&a[0]));
-    [top[0], top[1], bottom[0], bottom[1]]
-}
-
-fn sort_quad_points(quad: &Quad) -> (Quad, bool) {
-    let mut pairwise = Vec::with_capacity(16);
-    for a in quad {
-        for b in quad {
-            let vec = [a[0] - b[0], a[1] - b[1]];
-            pairwise.push((vec, vector_norm(vec)));
-        }
-    }
-
-    let mut sorted_ids: Vec<usize> = (0..pairwise.len()).collect();
-    sorted_ids.sort_by(|a, b| pairwise[*a].1.total_cmp(&pairwise[*b].1));
-    let mut long_side_vecs = [pairwise[sorted_ids[8]].0, pairwise[sorted_ids[10]].0];
-    if dot(long_side_vecs[0], long_side_vecs[1]) < 0.0 {
-        long_side_vecs[0] = [-long_side_vecs[0][0], -long_side_vecs[0][1]];
-    }
-
-    let structure_vec = [
-        (long_side_vecs[0][0] + long_side_vecs[1][0]).abs() * 0.5,
-        (long_side_vecs[0][1] + long_side_vecs[1][1]).abs() * 0.5,
-    ];
-    let sorted_norms: Vec<f32> = sorted_ids.iter().map(|id| pairwise[*id].1).collect();
-    let square = sorted_norms[4..12]
-        .iter()
-        .copied()
-        .fold((f32::MAX, f32::MIN), |(min_v, max_v), value| {
-            (min_v.min(value), max_v.max(value))
-        });
-    let mut vertical = structure_vec[0] * 1.2 <= structure_vec[1];
-    if square.1 - square.0 < 1e-3 {
-        vertical = false;
-    }
-
-    if vertical {
-        (reorder_quad_vertical(quad), true)
-    } else {
-        (reorder_quad_horizontal(quad), false)
-    }
-}
-
-fn clip_quad(quad: &Quad, width: f32, height: f32) -> Quad {
-    let mut clipped = *quad;
-    for point in &mut clipped {
-        point[0] = point[0].clamp(0.0, width);
-        point[1] = point[1].clamp(0.0, height);
-    }
-    clipped
-}
-
-fn scale_quad(quad: &Quad, scale_x: f32, scale_y: f32) -> Quad {
-    let mut scaled = *quad;
-    for point in &mut scaled {
-        point[0] *= scale_x;
-        point[1] *= scale_y;
-    }
-    scaled
-}
-
-fn quad_bbox(quad: &Quad) -> [f32; 4] {
-    let mut min_x = f32::MAX;
-    let mut min_y = f32::MAX;
-    let mut max_x = f32::MIN;
-    let mut max_y = f32::MIN;
-    for point in quad {
-        min_x = min_x.min(point[0]);
-        min_y = min_y.min(point[1]);
-        max_x = max_x.max(point[0]);
-        max_y = max_y.max(point[1]);
-    }
-    [min_x, min_y, max_x, max_y]
-}
-
-fn bbox_area(bbox: &[f32; 4]) -> f32 {
-    (bbox[2] - bbox[0]).max(0.0) * (bbox[3] - bbox[1]).max(0.0)
-}
-
-fn overlap_area(a: &[f32; 4], b: &[f32; 4]) -> f32 {
-    let x1 = a[0].max(b[0]);
-    let y1 = a[1].max(b[1]);
-    let x2 = a[2].min(b[2]);
-    let y2 = a[3].min(b[3]);
-    if x2 <= x1 || y2 <= y1 {
-        return 0.0;
-    }
-    (x2 - x1) * (y2 - y1)
-}
-
-fn horizontal_overlap(a: &[f32; 4], b: &[f32; 4]) -> f32 {
-    (a[2].min(b[2]) - a[0].max(b[0])).max(0.0)
-}
-
-fn vertical_overlap(a: &[f32; 4], b: &[f32; 4]) -> f32 {
-    (a[3].min(b[3]) - a[1].max(b[1])).max(0.0)
-}
-
-fn mean_mask_score(mask: &GrayImage, bbox: &[f32; 4]) -> f32 {
-    let x1 = bbox[0].floor().max(0.0) as u32;
-    let y1 = bbox[1].floor().max(0.0) as u32;
-    let x2 = bbox[2].ceil().min(mask.width() as f32) as u32;
-    let y2 = bbox[3].ceil().min(mask.height() as f32) as u32;
-    if x2 <= x1 || y2 <= y1 {
-        return 0.0;
-    }
-
-    let mut sum = 0u64;
-    let mut count = 0u64;
-    for y in y1..y2 {
-        for x in x1..x2 {
-            sum += mask.get_pixel(x, y)[0] as u64;
-            count += 1;
-        }
-    }
-    if count == 0 {
-        0.0
-    } else {
-        (sum as f32 / count as f32) / 255.0
-    }
-}
-
-fn enlarge_window(bbox: [f32; 4], image_width: f32, image_height: f32) -> [f32; 4] {
-    let w = bbox[2] - bbox[0];
-    let h = bbox[3] - bbox[1];
-    if w <= 0.0 || h <= 0.0 {
-        return [0.0, 0.0, 0.0, 0.0];
-    }
-
-    let a = 1.0f32;
-    let b = w + h;
-    let c = (1.0 - 2.5) * w * h;
-    let delta = (b * b - 4.0 * a * c).max(0.0).sqrt();
-    let grow = ((-b + delta) / (2.0 * a)).max(0.0) * 0.5;
-    let grow_x = grow.min(bbox[0]).min(image_width - bbox[2]);
-    let grow_y = grow.min(bbox[1]).min(image_height - bbox[3]);
-
-    [
-        (bbox[0] - grow_x).clamp(0.0, image_width),
-        (bbox[1] - grow_y).clamp(0.0, image_height),
-        (bbox[2] + grow_x).clamp(0.0, image_width),
-        (bbox[3] + grow_y).clamp(0.0, image_height),
-    ]
-}
-
-fn invert_binary(image: &GrayImage) -> GrayImage {
-    GrayImage::from_fn(image.width(), image.height(), |x, y| {
-        if image.get_pixel(x, y)[0] > 0 {
-            Luma([0u8])
-        } else {
-            Luma([255u8])
-        }
-    })
-}
-
-fn threshold_binary(image: &GrayImage, threshold: u8) -> GrayImage {
-    GrayImage::from_fn(image.width(), image.height(), |x, y| {
-        if image.get_pixel(x, y)[0] > threshold {
-            Luma([255u8])
-        } else {
-            Luma([0u8])
-        }
-    })
-}
-
-fn xor_sum(a: &GrayImage, b: &GrayImage) -> u64 {
-    a.pixels()
-        .zip(b.pixels())
-        .map(|(left, right)| (left[0] ^ right[0]) as u64)
-        .sum()
-}
-
-fn quads_intersect(a: &Quad, b: &Quad) -> bool {
-    let mut axes = Vec::with_capacity(8);
-    axes.extend(quad_axes(a));
-    axes.extend(quad_axes(b));
-
-    for axis in axes {
-        let (a_min, a_max) = project_quad(a, axis);
-        let (b_min, b_max) = project_quad(b, axis);
-        if a_max < b_min || b_max < a_min {
-            return false;
-        }
-    }
-    true
-}
-
-fn quad_axes(quad: &Quad) -> Vec<[f32; 2]> {
-    let mut axes = Vec::with_capacity(4);
-    for index in 0..4 {
-        let next = (index + 1) % 4;
-        let edge = [
-            quad[next][0] - quad[index][0],
-            quad[next][1] - quad[index][1],
-        ];
-        let normal = [-edge[1], edge[0]];
-        let norm = vector_norm(normal);
-        if norm > 0.0 {
-            axes.push([normal[0] / norm, normal[1] / norm]);
-        }
-    }
-    axes
-}
-
-fn project_quad(quad: &Quad, axis: [f32; 2]) -> (f32, f32) {
-    let mut min = f32::MAX;
-    let mut max = f32::MIN;
-    for point in quad {
-        let projection = point[0] * axis[0] + point[1] * axis[1];
-        min = min.min(projection);
-        max = max.max(projection);
-    }
-    (min, max)
-}
-
-fn perpendicular_distance(vector: [f32; 2], axis: [f32; 2], _unused: f32) -> f32 {
-    let axis_norm = vector_norm(axis).max(1e-6);
-    let dot = vector[0] * axis[0] + vector[1] * axis[1];
-    let vector_norm = vector_norm(vector).max(1e-6);
-    let cos = (dot / (vector_norm * axis_norm)).clamp(-1.0, 1.0);
-    (1.0 - cos * cos).max(0.0).sqrt() * vector_norm
-}
-
-fn vector_norm(vector: [f32; 2]) -> f32 {
-    (vector[0] * vector[0] + vector[1] * vector[1]).sqrt()
-}
-
-fn cross_2d(a: [f32; 2], b: [f32; 2]) -> f32 {
-    a[0] * b[1] - a[1] * b[0]
-}
-
-fn dot(a: [f32; 2], b: [f32; 2]) -> f32 {
-    a[0] * b[0] + a[1] * b[1]
-}
-
-trait BboxExt {
-    fn bbox_width(&self) -> f32;
-    fn bbox_height(&self) -> f32;
-}
-
-impl BboxExt for CtdBlock {
-    fn bbox_width(&self) -> f32 {
-        self.bbox[2] - self.bbox[0]
-    }
-
-    fn bbox_height(&self) -> f32 {
-        self.bbox[3] - self.bbox[1]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn test_block(bbox: [f32; 4], source_direction: TextDirection) -> CtdBlock {
-        CtdBlock {
-            bbox,
-            confidence: 0.9,
-            source_language: "unknown".to_string(),
-            source_direction,
-            lines: Vec::new(),
-            angle_deg: 0.0,
-            detected_font_size_px: 10.0,
-            distances: Vec::new(),
-            direction_vec: [1.0, 0.0],
-            direction_norm: 1.0,
-            merged: false,
-        }
-    }
-
-    #[test]
-    fn component_quad_tracks_orientation() {
-        let component = Component {
-            x: 0,
-            y: 0,
-            w: 30,
-            h: 8,
-            area: 40,
-            pixels: (0..20).map(|x| (x, 2 + (x / 5))).collect(),
-        };
-
-        let (quad, vertical) = component_quad(&component).expect("quad");
-        assert!(!vertical);
-        let bbox = quad_bbox(&quad);
-        assert!(bbox[2] > bbox[0]);
-        assert!(bbox[3] > bbox[1]);
-    }
-
-    #[test]
-    fn merge_text_lines_keeps_adjacent_horizontal_lines() {
-        let line_a = DetectedLine {
-            quad: [[0.0, 0.0], [20.0, 0.0], [20.0, 8.0], [0.0, 8.0]],
-            vertical: false,
-            score: 0.9,
-        };
-        let line_b = DetectedLine {
-            quad: [[18.0, 0.0], [38.0, 0.0], [38.0, 8.0], [18.0, 8.0]],
-            vertical: false,
-            score: 0.9,
-        };
-        let mut block_a = CtdBlock::from_line(&line_a);
-        let mut block_b = CtdBlock::from_line(&line_b);
-        examine_block(&mut block_a, 100, 100, true);
-        examine_block(&mut block_b, 100, 100, true);
-
-        assert!(try_merge_text_line(&mut block_a, &mut block_b, 2.0));
-        assert_eq!(block_a.lines.len(), 2);
+        let with_blocks = refine_segmentation_mask(&image, &pred_mask, &[block]);
+        let without_blocks = refine_segmentation_mask(&image, &pred_mask, &[]);
+        assert_eq!(with_blocks, without_blocks);
     }
 
     #[test]
-    fn transformed_regions_fall_back_to_bbox_without_ctd_metadata() {
-        let image = DynamicImage::ImageRgb8(RgbImage::from_pixel(32, 32, Rgb([255, 255, 255])));
+    fn extract_text_block_regions_falls_back_to_bbox_without_lines() {
+        let image = DynamicImage::ImageRgb8(RgbImage::from_pixel(24, 24, Rgb([255, 255, 255])));
         let block = TextBlock {
             x: 4.0,
-            y: 6.0,
+            y: 5.0,
             width: 10.0,
-            height: 12.0,
+            height: 8.0,
             ..Default::default()
         };
 
         let regions = extract_text_block_regions(&image, &block);
         assert_eq!(regions.len(), 1);
         assert_eq!(regions[0].width(), 10);
-        assert_eq!(regions[0].height(), 12);
+        assert_eq!(regions[0].height(), 8);
     }
 
     #[test]
@@ -1965,233 +379,4 @@ mod tests {
         assert!(crop.width() > 12);
         assert!(crop.height() > 8);
     }
-
-    #[test]
-    fn group_output_builds_line_only_ctd_blocks() {
-        let line = DetectedLine {
-            quad: [[10.0, 10.0], [30.0, 10.0], [30.0, 18.0], [10.0, 18.0]],
-            vertical: false,
-            score: 0.95,
-        };
-        let mask = GrayImage::from_fn(48, 48, |x, y| {
-            if (10..30).contains(&x) && (10..18).contains(&y) {
-                Luma([255])
-            } else {
-                Luma([0])
-            }
-        });
-
-        let blocks = group_output(&[line], &mask, 48, 48);
-        assert_eq!(blocks.len(), 1);
-        assert_eq!(blocks[0].detector.as_deref(), Some("ctd"));
-        assert_eq!(blocks[0].source_direction, Some(TextDirection::Horizontal));
-        assert_eq!(blocks[0].line_polygons.as_ref().map(Vec::len), Some(1));
-        assert!(blocks[0].detected_font_size_px.unwrap_or_default() > 0.0);
-    }
-
-    #[test]
-    fn transformed_regions_rotate_vertical_ctd_lines() {
-        let mut image = RgbImage::from_pixel(48, 48, Rgb([255, 255, 255]));
-        for y in 8..40 {
-            for x in 20..28 {
-                image.put_pixel(x, y, Rgb([0, 0, 0]));
-            }
-        }
-        let block = TextBlock {
-            x: 18.0,
-            y: 8.0,
-            width: 12.0,
-            height: 32.0,
-            line_polygons: Some(vec![[[20.0, 8.0], [28.0, 8.0], [28.0, 40.0], [20.0, 40.0]]]),
-            source_direction: Some(TextDirection::Vertical),
-            rotation_deg: Some(0.0),
-            detected_font_size_px: Some(8.0),
-            detector: Some("ctd".to_string()),
-            ..Default::default()
-        };
-
-        let regions = extract_text_block_regions(&DynamicImage::ImageRgb8(image), &block);
-        assert_eq!(regions.len(), 1);
-        assert!(regions[0].width() > regions[0].height());
-    }
-
-    #[test]
-    fn refine_mask_returns_pixels_for_ctd_blocks() {
-        let mut image = RgbImage::from_pixel(32, 32, Rgb([255, 255, 255]));
-        let pred_mask = GrayImage::from_fn(32, 32, |x, y| {
-            if (10..22).contains(&x) && (12..18).contains(&y) {
-                Luma([255])
-            } else {
-                Luma([0])
-            }
-        });
-        for y in 12..18 {
-            for x in 10..22 {
-                image.put_pixel(x, y, Rgb([0, 0, 0]));
-            }
-        }
-        let block = TextBlock {
-            x: 10.0,
-            y: 12.0,
-            width: 12.0,
-            height: 6.0,
-            line_polygons: Some(vec![[
-                [10.0, 12.0],
-                [22.0, 12.0],
-                [22.0, 18.0],
-                [10.0, 18.0],
-            ]]),
-            source_direction: Some(TextDirection::Horizontal),
-            rotation_deg: Some(0.0),
-            detected_font_size_px: Some(6.0),
-            detector: Some("ctd".to_string()),
-            ..Default::default()
-        };
-
-        let refined = refine_mask(&image, &pred_mask, &[block]);
-        assert_eq!(refined.get_pixel(0, 0)[0], 0);
-        assert!(refined.get_pixel(16, 15)[0] > 0);
-    }
-
-    #[test]
-    fn refine_segmentation_mask_thresholds_when_blocks_are_missing() {
-        let image = DynamicImage::ImageRgb8(RgbImage::from_pixel(16, 16, Rgb([255, 255, 255])));
-        let pred_mask = GrayImage::from_fn(16, 16, |x, y| {
-            if (4..12).contains(&x) && (5..11).contains(&y) {
-                Luma([200])
-            } else {
-                Luma([0])
-            }
-        });
-
-        let mask = refine_segmentation_mask(&image, &pred_mask, &[]);
-        assert_eq!(mask.get_pixel(0, 0)[0], 0);
-        assert!(mask.get_pixel(8, 8)[0] > 0);
-    }
-
-    #[test]
-    fn paragraph_merge_joins_stacked_horizontal_blocks() {
-        let make_block = |lines: Vec<Quad>| {
-            let mut block = CtdBlock {
-                bbox: [0.0, 0.0, 0.0, 0.0],
-                confidence: 0.9,
-                source_language: "unknown".to_string(),
-                source_direction: TextDirection::Horizontal,
-                lines,
-                angle_deg: 0.0,
-                detected_font_size_px: 0.0,
-                distances: Vec::new(),
-                direction_vec: [1.0, 0.0],
-                direction_norm: 1.0,
-                merged: false,
-            };
-            block.adjust_bbox(false);
-            examine_block(&mut block, 2000, 2000, true);
-            block
-        };
-
-        let blocks = vec![
-            make_block(vec![[
-                [10.0, 10.0],
-                [110.0, 10.0],
-                [110.0, 30.0],
-                [10.0, 30.0],
-            ]]),
-            make_block(vec![[
-                [12.0, 42.0],
-                [108.0, 42.0],
-                [108.0, 60.0],
-                [12.0, 60.0],
-            ]]),
-            make_block(vec![
-                [[9.0, 74.0], [112.0, 74.0], [112.0, 94.0], [9.0, 94.0]],
-                [[8.0, 106.0], [105.0, 106.0], [105.0, 126.0], [8.0, 126.0]],
-            ]),
-        ];
-
-        let merged = merge_paragraph_blocks(blocks, 2000, 2000);
-        assert_eq!(merged.len(), 1);
-        assert_eq!(merged[0].lines.len(), 4);
-    }
-
-    #[test]
-    fn paragraph_merge_does_not_skip_over_intervening_block() {
-        let make_block = |lines: Vec<Quad>| {
-            let mut block = CtdBlock {
-                bbox: [0.0, 0.0, 0.0, 0.0],
-                confidence: 0.9,
-                source_language: "unknown".to_string(),
-                source_direction: TextDirection::Horizontal,
-                lines,
-                angle_deg: 0.0,
-                detected_font_size_px: 0.0,
-                distances: Vec::new(),
-                direction_vec: [1.0, 0.0],
-                direction_norm: 1.0,
-                merged: false,
-            };
-            block.adjust_bbox(false);
-            examine_block(&mut block, 2000, 2000, true);
-            block
-        };
-
-        let top = make_block(vec![[
-            [10.0, 10.0],
-            [110.0, 10.0],
-            [110.0, 28.0],
-            [10.0, 28.0],
-        ]]);
-        let blocker = make_block(vec![[
-            [42.0, 32.0],
-            [78.0, 32.0],
-            [78.0, 76.0],
-            [42.0, 76.0],
-        ]]);
-        let bottom = make_block(vec![[
-            [12.0, 38.0],
-            [108.0, 38.0],
-            [108.0, 56.0],
-            [12.0, 56.0],
-        ]]);
-
-        let merged = merge_paragraph_blocks(vec![top, blocker, bottom], 2000, 2000);
-        assert_eq!(merged.len(), 3);
-    }
-
-    #[test]
-    fn sort_regions_stays_stable_across_row_boundaries() {
-        let left_lower = test_block([0.0, 9.0, 2.0, 11.0], TextDirection::Horizontal);
-        let middle = test_block([1.0, 4.0, 3.0, 6.0], TextDirection::Horizontal);
-        let right_upper = test_block([2.0, -1.0, 4.0, 1.0], TextDirection::Horizontal);
-        let sorted = sort_regions(vec![left_lower, middle, right_upper]);
-        let bboxes = sorted.iter().map(|block| block.bbox).collect::<Vec<_>>();
-
-        assert_eq!(
-            bboxes,
-            vec![
-                [0.0, 9.0, 2.0, 11.0],
-                [1.0, 4.0, 3.0, 6.0],
-                [2.0, -1.0, 4.0, 1.0],
-            ]
-        );
-    }
-
-    #[test]
-    fn sort_regions_orders_vertical_blocks_right_to_left_then_top_to_bottom() {
-        let sorted = sort_regions(vec![
-            test_block([10.0, 20.0, 18.0, 28.0], TextDirection::Vertical),
-            test_block([30.0, 15.0, 38.0, 23.0], TextDirection::Vertical),
-            test_block([30.0, 5.0, 38.0, 13.0], TextDirection::Vertical),
-        ]);
-        let bboxes = sorted.iter().map(|block| block.bbox).collect::<Vec<_>>();
-
-        assert_eq!(
-            bboxes,
-            vec![
-                [30.0, 5.0, 38.0, 13.0],
-                [30.0, 15.0, 38.0, 23.0],
-                [10.0, 20.0, 18.0, 28.0],
-            ]
-        );
-    }
 }

koharu-ml/tests/comic_text_detector.rs

@@ -14,25 +14,16 @@ async fn comic_text_detector() -> anyhow::Result<()> {
     let img = image::open(Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/1.jpg"))?;
     let detection = model.inference(&img)?;
 
-    assert!(
-        !detection.text_blocks.is_empty(),
-        "expected CTD blocks, got line_polygons={}, mask_pixels={}",
-        detection.line_polygons.len(),
-        detection.mask.iter().filter(|&&v| v > 0u8).count()
-    );
-    assert!(
-        detection.mask.iter().any(|&v| v > 0u8),
-        "expected CTD mask, got line_polygons={}",
-        detection.line_polygons.len()
-    );
+    assert!(!detection.text_blocks.is_empty(), "expected CTD boxes");
+    assert!(detection.mask.iter().any(|&v| v > 0u8), "expected CTD mask");
     assert_eq!(detection.shrink_map.dimensions(), img.dimensions());
     assert_eq!(detection.threshold_map.dimensions(), img.dimensions());
-    assert!(detection.line_polygons.iter().all(|line| line.len() == 4));
+    assert!(detection.line_polygons.is_empty());
     assert!(
         detection
             .text_blocks
             .iter()
-            .any(|block| block.detector.as_deref() == Some("ctd"))
+            .all(|block| block.line_polygons.is_none() && block.detector.is_none())
     );
 
     Ok(())

ui/app/(app)/page.tsx

@@ -43,7 +43,7 @@ export default function Page() {
         onLayoutChanged={onLayoutChanged}
         className='flex min-h-0 flex-1'
       >
-        <Panel id='left' defaultSize={220} minSize={160} maxSize={360}>
+        <Panel id='left' defaultSize={180} minSize={120} maxSize={300}>
           <Navigator />
         </Panel>
         <Separator className='bg-border/40 hover:bg-border w-1 transition-colors' />
@@ -56,7 +56,7 @@ export default function Page() {
           </AppErrorBoundary>
         </Panel>
         <Separator className='bg-border/40 hover:bg-border w-1 transition-colors' />
-        <Panel id='right' defaultSize={320} minSize={320} maxSize={460}>
+        <Panel id='right' defaultSize={280} minSize={260} maxSize={400}>
           <AppErrorBoundary>
             <Panels />
           </AppErrorBoundary>

ui/components/Panels.tsx

@@ -56,7 +56,10 @@ export function Panels() {
           className='min-h-0 flex-1 px-2 pb-2 data-[state=inactive]:hidden'
           data-testid='panels-layout'
         >
-          <ScrollArea className='h-full' viewportClassName='pr-1'>
+          <ScrollArea
+            className='h-full'
+            viewportClassName='pr-1 [&>div]:!block'
+          >
             <div className='pt-1'>
               <RenderControlsPanel />
             </div>

ui/components/canvas/TextBlockLayer.tsx

@@ -50,6 +50,14 @@ export function TextBlockLayer({
         pointerEvents: 'none',
       }}
     >
+      {showSprites &&
+        textBlocks.map((block, index) => (
+          <BlockSprite
+            key={`sprite-${block.id ?? index}`}
+            block={block}
+            scale={scale}
+          />
+        ))}
       {textBlocks.map((block, index) => (
         <TextBlockItem
           key={block.id ?? `fallback-${index}`}
@@ -58,7 +66,6 @@ export function TextBlockLayer({
           scale={scale}
           selected={index === selectedIndex}
           interactive={interactive}
-          showSprite={showSprites}
           onSelect={onSelect}
           onUpdate={(updates) => void replaceBlock(index, updates)}
         />
@@ -73,7 +80,6 @@ type TextBlockItemProps = {
   scale: number
   selected: boolean
   interactive: boolean
-  showSprite?: boolean
   onSelect: (index: number) => void
   onUpdate: (updates: Partial<TextBlock>) => void
 }
@@ -93,7 +99,6 @@ function TextBlockItem({
   scale,
   selected,
   interactive,
-  showSprite,
   onSelect,
   onUpdate,
 }: TextBlockItemProps) {
@@ -213,9 +218,6 @@ function TextBlockItem({
         cursor: interactive ? 'move' : 'default',
       }}
     >
-      {/* Sprite image at natural size */}
-      {showSprite && <BlockSprite hash={block.rendered} />}
-
       {/* Annotation border */}
       <div
         className={`absolute inset-0 rounded ${
@@ -242,15 +244,23 @@ function TextBlockItem({
   )
 }
 
-function BlockSprite({ hash }: { hash?: string }) {
-  const { data: src } = useBlobImage(hash)
+function BlockSprite({ block, scale }: { block: TextBlock; scale: number }) {
+  const { data: src } = useBlobImage(block.rendered)
   if (!src) return null
+  const x = (block.renderX ?? block.x) * scale
+  const y = (block.renderY ?? block.y) * scale
   return (
     <img
       alt=''
       src={src}
       draggable={false}
-      className='pointer-events-none absolute top-0 left-0 select-none'
+      className='pointer-events-none absolute select-none'
+      style={{
+        top: 0,
+        left: 0,
+        transformOrigin: 'top left',
+        transform: `translate(${x}px, ${y}px) scale(${scale})`,
+      }}
     />
   )
 }

ui/components/panels/RenderControlsPanel.tsx

@@ -29,13 +29,7 @@ import {
   TooltipContent,
   TooltipTrigger,
 } from '@/components/ui/tooltip'
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from '@/components/ui/select'
+import { FontSelect } from '@/components/ui/font-select'
 import { useEditorUiStore } from '@/lib/stores/editorUiStore'
 import { usePreferencesStore } from '@/lib/stores/preferencesStore'
 import { useListFonts } from '@/lib/api/system/system'
@@ -349,7 +343,8 @@ export function RenderControlsPanel() {
   ]
 
   return (
-    <div className='flex w-full min-w-0 flex-col gap-1.5'>
+    <div className='flex w-full min-w-0 flex-col gap-2'>
+      {/* Scope indicator */}
       <div className='flex items-center justify-end'>
         <span
           data-testid='render-scope-indicator'
@@ -362,16 +357,30 @@ export function RenderControlsPanel() {
         </span>
       </div>
 
-      <div className='grid w-full min-w-0 grid-cols-[3.5rem_minmax(0,1fr)] items-center gap-1.5'>
-        <span className='text-muted-foreground text-[10px] font-medium tracking-wide uppercase'>
-          {fontLabel}
-        </span>
-
+      {/* Font + Color */}
+      <div className='flex flex-col gap-0.5'>
+        <div className='flex items-baseline justify-between'>
+          <span className='text-muted-foreground text-[10px] font-medium uppercase'>
+            {fontLabel}
+          </span>
+          <span className='text-muted-foreground text-[10px] font-medium uppercase'>
+            {t('render.fontColorLabel')}
+          </span>
+        </div>
         <div className='flex min-w-0 items-center gap-1.5'>
           <div className='min-w-0 flex-1'>
-            <Select
+            <FontSelect
+              data-testid='render-font-select'
               value={currentFont}
-              onValueChange={(value) => {
+              options={fontOptions}
+              disabled={fontOptions.length === 0}
+              placeholder={t('render.fontPlaceholder')}
+              triggerStyle={
+                currentFontFamilyName
+                  ? { fontFamily: currentFontFamilyName }
+                  : undefined
+              }
+              onChange={(value) => {
                 const nextFamilies = mergeFontFamilies(
                   value,
                   selectedBlock?.style?.fontFamilies,
@@ -390,135 +399,92 @@ export function RenderControlsPanel() {
                 }))
                 void updateTextBlocks(nextBlocks)
               }}
-              disabled={fontOptions.length === 0}
-            >
-              <SelectTrigger
-                data-testid='render-font-select'
-                size='sm'
-                className='h-7 w-full min-w-0 text-xs'
-                style={
-                  currentFontFamilyName
-                    ? { fontFamily: currentFontFamilyName }
-                    : undefined
-                }
-              >
-                <SelectValue placeholder={t('render.fontPlaceholder')} />
-              </SelectTrigger>
-              <SelectContent position='popper'>
-                {fontOptions.map((font, index) => (
-                  <SelectItem
-                    key={font.postScriptName}
-                    value={font.postScriptName}
-                    style={{ fontFamily: font.familyName }}
-                    data-testid={`render-font-option-${index}`}
-                  >
-                    {font.familyName}
-                  </SelectItem>
-                ))}
-              </SelectContent>
-            </Select>
+            />
           </div>
-
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <div>
-                <ColorPicker
-                  value={currentColorHex}
-                  disabled={!hasBlocks}
-                  triggerTestId='render-color-trigger'
-                  pickerTestId='render-color-picker'
-                  swatchTestId='render-color-swatch'
-                  inputTestId='render-color-input'
-                  pickButtonTestId='render-color-pick'
-                  onChange={(hex) => {
-                    const nextColor = hexToColor(hex, currentColor[3] ?? 255)
-                    if (applyStyleToSelected({ color: nextColor })) return
-                    applyStyleToAll({ color: nextColor })
-                  }}
-                  className='h-7 w-7'
-                />
-              </div>
-            </TooltipTrigger>
-            <TooltipContent side='bottom' sideOffset={4}>
-              {t('render.fontColorLabel')}
-            </TooltipContent>
-          </Tooltip>
+          <ColorPicker
+            value={currentColorHex}
+            disabled={!hasBlocks}
+            triggerTestId='render-color-trigger'
+            pickerTestId='render-color-picker'
+            swatchTestId='render-color-swatch'
+            inputTestId='render-color-input'
+            pickButtonTestId='render-color-pick'
+            onChange={(hex) => {
+              const nextColor = hexToColor(hex, currentColor[3] ?? 255)
+              if (applyStyleToSelected({ color: nextColor })) return
+              applyStyleToAll({ color: nextColor })
+            }}
+            className='size-7'
+          />
         </div>
       </div>
 
-      <div className='grid w-full min-w-0 grid-cols-[3.5rem_minmax(0,1fr)] items-center gap-1.5'>
-        <span className='text-muted-foreground text-[10px] font-medium tracking-wide uppercase'>
+      {/* Size / Effect / Align */}
+      <div className='grid w-full grid-cols-[minmax(0,1fr)_auto_auto] items-end gap-x-2'>
+        <span className='text-muted-foreground text-[10px] font-medium uppercase'>
           {fontSizeLabel}
         </span>
-
-        <div className='flex min-w-0 items-center gap-1'>
-          <div className='border-input bg-background flex w-auto min-w-0 shrink-0 items-center rounded-md border shadow-xs'>
-            <Button
-              type='button'
-              variant='ghost'
-              size='icon-sm'
-              aria-label={`${fontSizeLabel} -`}
-              className='size-7 rounded-r-none border-r'
-              disabled={selectedBlockIndex === undefined}
-              onClick={() => {
-                const next = Math.max(
-                  6,
-                  Math.round((currentFontSize ?? 16) - 1),
-                )
-                applyStyleToSelected({ fontSize: next })
-              }}
-            >
-              <MinusIcon className='size-3' />
-            </Button>
-
-            <Input
-              type='number'
-              step='1'
-              min='6'
-              max='300'
-              inputMode='numeric'
-              className='h-7 w-14 min-w-0 [appearance:textfield] rounded-none border-0 px-1.5 text-center text-[11px] shadow-none focus-visible:ring-0 [&::-webkit-inner-spin-button]:appearance-none [&::-webkit-outer-spin-button]:appearance-none'
-              data-testid='render-font-size'
-              disabled={selectedBlockIndex === undefined}
-              value={
-                currentFontSize !== undefined ? Math.round(currentFontSize) : ''
-              }
-              placeholder='auto'
-              onChange={(event) => {
-                const parsed = Number.parseInt(event.target.value, 10)
-                if (!Number.isFinite(parsed) || parsed < 1) return
-                applyStyleToSelected({ fontSize: Math.min(300, parsed) })
-              }}
-            />
-
-            <Button
-              type='button'
-              variant='ghost'
-              size='icon-sm'
-              aria-label={`${fontSizeLabel} +`}
-              className='size-7 rounded-l-none border-l'
-              disabled={selectedBlockIndex === undefined}
-              onClick={() => {
-                const next = Math.min(
-                  300,
-                  Math.round((currentFontSize ?? 16) + 1),
-                )
-                applyStyleToSelected({ fontSize: next })
-              }}
-            >
-              <PlusIcon className='size-3' />
-            </Button>
-          </div>
-          <span className='text-muted-foreground text-[10px]'>px</span>
-        </div>
-      </div>
-
-      <div className='grid w-full min-w-0 grid-cols-[3.5rem_minmax(0,1fr)] items-center gap-1.5'>
-        <span className='text-muted-foreground text-[10px] font-medium tracking-wide uppercase'>
+        <span className='text-muted-foreground text-[10px] font-medium uppercase'>
           {effectLabel}
         </span>
+        <span className='text-muted-foreground text-[10px] font-medium uppercase'>
+          {alignLabel}
+        </span>
+
+        <div className='border-input bg-background flex min-w-0 items-center rounded-md border shadow-xs'>
+          <Button
+            type='button'
+            variant='ghost'
+            size='icon-sm'
+            aria-label={`${fontSizeLabel} -`}
+            className='size-7 shrink-0 rounded-r-none border-r'
+            disabled={selectedBlockIndex === undefined}
+            onClick={() => {
+              const next = Math.max(6, Math.round((currentFontSize ?? 16) - 1))
+              applyStyleToSelected({ fontSize: next })
+            }}
+          >
+            <MinusIcon className='size-3' />
+          </Button>
+          <Input
+            type='number'
+            step='1'
+            min='6'
+            max='300'
+            inputMode='numeric'
+            className='h-7 min-w-0 flex-1 [appearance:textfield] rounded-none border-0 px-1 text-center text-xs shadow-none focus-visible:ring-0 [&::-webkit-inner-spin-button]:appearance-none [&::-webkit-outer-spin-button]:appearance-none'
+            data-testid='render-font-size'
+            disabled={selectedBlockIndex === undefined}
+            value={
+              currentFontSize !== undefined ? Math.round(currentFontSize) : ''
+            }
+            placeholder='auto'
+            onChange={(event) => {
+              const parsed = Number.parseInt(event.target.value, 10)
+              if (!Number.isFinite(parsed) || parsed < 1) return
+              applyStyleToSelected({ fontSize: Math.min(300, parsed) })
+            }}
+          />
+          <Button
+            type='button'
+            variant='ghost'
+            size='icon-sm'
+            aria-label={`${fontSizeLabel} +`}
+            className='size-7 shrink-0 rounded-l-none border-l'
+            disabled={selectedBlockIndex === undefined}
+            onClick={() => {
+              const next = Math.min(
+                300,
+                Math.round((currentFontSize ?? 16) + 1),
+              )
+              applyStyleToSelected({ fontSize: next })
+            }}
+          >
+            <PlusIcon className='size-3' />
+          </Button>
+        </div>
 
-        <div className='flex min-w-0 flex-wrap items-center gap-1'>
+        <div className='flex items-center gap-1'>
           {effectItems.map((item) => {
             const active = currentEffect[item.key]
             const Icon = item.Icon
@@ -531,7 +497,7 @@ export function RenderControlsPanel() {
                     aria-label={item.label}
                     data-testid={`render-effect-toggle-${item.key}`}
                     className={cn(
-                      'size-7',
+                      'size-7 shrink-0',
                       active &&
                         'bg-primary text-primary-foreground border-primary hover:bg-primary/90',
                     )}
@@ -555,14 +521,8 @@ export function RenderControlsPanel() {
             )
           })}
         </div>
-      </div>
-
-      <div className='grid w-full min-w-0 grid-cols-[3.5rem_minmax(0,1fr)] items-center gap-1.5'>
-        <span className='text-muted-foreground text-[10px] font-medium tracking-wide uppercase'>
-          {alignLabel}
-        </span>
 
-        <div className='flex min-w-0 flex-wrap items-center gap-1'>
+        <div className='flex items-center gap-1'>
           {textAlignItems.map((item) => {
             const active = currentTextAlign === item.value
             const Icon = item.Icon
@@ -576,7 +536,7 @@ export function RenderControlsPanel() {
                     data-testid={`render-align-${item.value}`}
                     disabled={!hasBlocks}
                     className={cn(
-                      'size-7',
+                      'size-7 shrink-0',
                       active &&
                         'bg-primary text-primary-foreground border-primary hover:bg-primary/90',
                     )}
@@ -598,12 +558,12 @@ export function RenderControlsPanel() {
         </div>
       </div>
 
-      <div className='grid w-full min-w-0 grid-cols-[3.5rem_minmax(0,1fr)] items-center gap-1.5'>
-        <span className='text-muted-foreground text-[10px] font-medium tracking-wide uppercase'>
+      {/* Border / Stroke */}
+      <div className='flex flex-col gap-0.5'>
+        <span className='text-muted-foreground text-[10px] font-medium uppercase'>
           {strokeLabel}
         </span>
-
-        <div className='flex min-w-0 flex-wrap items-center gap-1'>
+        <div className='flex min-w-0 items-center gap-1'>
           <Tooltip>
             <TooltipTrigger asChild>
               <Button
@@ -648,7 +608,7 @@ export function RenderControlsPanel() {
                       color: hexToColor(hex, currentStroke.color[3] ?? 255),
                     })
                   }}
-                  className='h-7 w-7'
+                  className='size-7'
                 />
               </div>
             </TooltipTrigger>
@@ -657,60 +617,53 @@ export function RenderControlsPanel() {
             </TooltipContent>
           </Tooltip>
 
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <div className='border-input bg-background flex w-auto min-w-0 shrink-0 items-center rounded-md border shadow-xs'>
-                <Button
-                  type='button'
-                  variant='ghost'
-                  size='icon-sm'
-                  aria-label={`${strokeWidthLabel} -`}
-                  className='size-7 rounded-r-none border-r'
-                  onClick={() =>
-                    updateStrokeWidth(currentStrokeWidth - STROKE_WIDTH_STEP)
-                  }
-                >
-                  <MinusIcon className='size-3' />
-                </Button>
-
-                <Input
-                  type='number'
-                  step={String(STROKE_WIDTH_STEP)}
-                  min={String(MIN_STROKE_WIDTH)}
-                  max={String(MAX_STROKE_WIDTH)}
-                  inputMode='decimal'
-                  className='h-7 w-14 min-w-0 [appearance:textfield] rounded-none border-0 px-1.5 text-center text-[11px] shadow-none focus-visible:ring-0 [&::-webkit-inner-spin-button]:appearance-none [&::-webkit-outer-spin-button]:appearance-none'
-                  data-testid='render-stroke-width'
-                  value={
-                    Number.isFinite(currentStrokeWidth)
-                      ? currentStrokeWidth
-                      : DEFAULT_STROKE_WIDTH
-                  }
-                  onChange={(event) => {
-                    const parsed = Number.parseFloat(event.target.value)
-                    if (!Number.isFinite(parsed)) return
-                    updateStrokeWidth(parsed)
-                  }}
-                />
+          <div className='border-input bg-background flex min-w-0 flex-1 items-center rounded-md border shadow-xs'>
+            <Button
+              type='button'
+              variant='ghost'
+              size='icon-sm'
+              aria-label={`${strokeWidthLabel} -`}
+              className='size-7 shrink-0 rounded-r-none border-r'
+              onClick={() =>
+                updateStrokeWidth(currentStrokeWidth - STROKE_WIDTH_STEP)
+              }
+            >
+              <MinusIcon className='size-3' />
+            </Button>
 
-                <Button
-                  type='button'
-                  variant='ghost'
-                  size='icon-sm'
-                  aria-label={`${strokeWidthLabel} +`}
-                  className='size-7 rounded-l-none border-l'
-                  onClick={() =>
-                    updateStrokeWidth(currentStrokeWidth + STROKE_WIDTH_STEP)
-                  }
-                >
-                  <PlusIcon className='size-3' />
-                </Button>
-              </div>
-            </TooltipTrigger>
-            <TooltipContent side='bottom' sideOffset={4}>
-              {strokeWidthLabel}
-            </TooltipContent>
-          </Tooltip>
+            <Input
+              type='number'
+              step={String(STROKE_WIDTH_STEP)}
+              min={String(MIN_STROKE_WIDTH)}
+              max={String(MAX_STROKE_WIDTH)}
+              inputMode='decimal'
+              className='h-7 min-w-0 flex-1 [appearance:textfield] rounded-none border-0 px-1 text-center text-xs shadow-none focus-visible:ring-0 [&::-webkit-inner-spin-button]:appearance-none [&::-webkit-outer-spin-button]:appearance-none'
+              data-testid='render-stroke-width'
+              value={
+                Number.isFinite(currentStrokeWidth)
+                  ? currentStrokeWidth
+                  : DEFAULT_STROKE_WIDTH
+              }
+              onChange={(event) => {
+                const parsed = Number.parseFloat(event.target.value)
+                if (!Number.isFinite(parsed)) return
+                updateStrokeWidth(parsed)
+              }}
+            />
+
+            <Button
+              type='button'
+              variant='ghost'
+              size='icon-sm'
+              aria-label={`${strokeWidthLabel} +`}
+              className='size-7 shrink-0 rounded-l-none border-l'
+              onClick={() =>
+                updateStrokeWidth(currentStrokeWidth + STROKE_WIDTH_STEP)
+              }
+            >
+              <PlusIcon className='size-3' />
+            </Button>
+          </div>
         </div>
       </div>
     </div>

ui/components/ui/color-picker.tsx

@@ -1,5 +1,6 @@
 'use client'
 
+import { useRef, useState, useCallback, useEffect } from 'react'
 import { HexColorInput, HexColorPicker } from 'react-colorful'
 import { Button } from '@/components/ui/button'
 import {
@@ -43,6 +44,21 @@ export function ColorPicker({
   inputTestId,
   pickButtonTestId,
 }: ColorPickerProps) {
+  const [localColor, setLocalColor] = useState(value)
+  const dragging = useRef(false)
+
+  // Sync external value when not dragging
+  useEffect(() => {
+    if (!dragging.current) setLocalColor(value)
+  }, [value])
+
+  const handlePointerUp = useCallback(() => {
+    if (dragging.current) {
+      dragging.current = false
+      onChange(localColor)
+    }
+  }, [localColor, onChange])
+
   const canUseEyeDropper =
     typeof window !== 'undefined' &&
     typeof (window as EyeDropperWindow).EyeDropper === 'function'
@@ -54,7 +70,9 @@ export function ColorPicker({
     try {
       const eyeDropper = new EyeDropperCtor()
       const result = await eyeDropper.open()
-      onChange(normalizeHex(result.sRGBHex))
+      const color = normalizeHex(result.sRGBHex)
+      setLocalColor(color)
+      onChange(color)
     } catch (error) {
       const maybeDomException = error as DOMException | undefined
       if (maybeDomException?.name === 'AbortError') return
@@ -76,29 +94,38 @@ export function ColorPicker({
           <div
             data-testid={swatchTestId}
             className='size-4 rounded-sm'
-            style={{ backgroundColor: value }}
+            style={{ backgroundColor: localColor }}
           />
         </button>
       </PopoverTrigger>
       <PopoverContent className='w-64 p-3' sideOffset={8}>
         <div className='space-y-3'>
-          <div data-testid={pickerTestId}>
+          {/* eslint-disable-next-line jsx-a11y/no-static-element-interactions */}
+          <div data-testid={pickerTestId} onPointerUp={handlePointerUp}>
             <HexColorPicker
-              color={value}
-              onChange={(color) => onChange(normalizeHex(color))}
+              color={localColor}
+              onChange={(color) => {
+                const normalized = normalizeHex(color)
+                dragging.current = true
+                setLocalColor(normalized)
+              }}
             />
           </div>
 
           <div className='flex items-center gap-2'>
             <HexColorInput
-              color={value}
+              color={localColor}
               prefixed
               data-testid={inputTestId}
               spellCheck={false}
               disabled={disabled}
               aria-label='Hex color code'
               className='border-input bg-background focus-visible:border-ring focus-visible:ring-ring/50 h-8 min-w-0 flex-1 rounded-md border px-2 font-mono text-xs uppercase shadow-xs transition outline-none focus-visible:ring-[3px]'
-              onChange={(color) => onChange(normalizeHex(color))}
+              onChange={(color) => {
+                const normalized = normalizeHex(color)
+                setLocalColor(normalized)
+                onChange(normalized)
+              }}
             />
 
             {canUseEyeDropper && (

ui/components/ui/font-select.tsx

@@ -0,0 +1,165 @@
+'use client'
+
+import { useRef, useState, useMemo, useCallback } from 'react'
+import { useVirtualizer } from '@tanstack/react-virtual'
+import { CheckIcon, ChevronDownIcon } from 'lucide-react'
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from '@/components/ui/popover'
+import { ScrollArea } from '@/components/ui/scroll-area'
+import { cn } from '@/lib/utils'
+
+const ITEM_HEIGHT = 28
+const MAX_VISIBLE = 10
+
+type FontOption = {
+  familyName: string
+  postScriptName: string
+}
+
+type FontSelectProps = {
+  value: string
+  options: FontOption[]
+  disabled?: boolean
+  placeholder?: string
+  className?: string
+  triggerClassName?: string
+  triggerStyle?: React.CSSProperties
+  onChange: (value: string) => void
+  'data-testid'?: string
+}
+
+export function FontSelect({
+  value,
+  options,
+  disabled,
+  placeholder,
+  className,
+  triggerClassName,
+  triggerStyle,
+  onChange,
+  ...props
+}: FontSelectProps) {
+  const [open, setOpen] = useState(false)
+  const [search, setSearch] = useState('')
+  const scrollRef = useRef<HTMLDivElement>(null)
+  const inputRef = useRef<HTMLInputElement>(null)
+
+  const filtered = useMemo(() => {
+    if (!search) return options
+    const lower = search.toLowerCase()
+    return options.filter((f) => f.familyName.toLowerCase().includes(lower))
+  }, [options, search])
+
+  const virtualizer = useVirtualizer({
+    count: filtered.length,
+    getScrollElement: () => scrollRef.current,
+    estimateSize: () => ITEM_HEIGHT,
+    overscan: 5,
+    enabled: open,
+  })
+
+  const viewportRef = useCallback(
+    (node: HTMLDivElement | null) => {
+      scrollRef.current = node
+      if (node) virtualizer.measure()
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [open],
+  )
+
+  const selectedLabel = options.find(
+    (f) => f.postScriptName === value || f.familyName === value,
+  )?.familyName
+
+  const listHeight = Math.min(filtered.length, MAX_VISIBLE) * ITEM_HEIGHT
+
+  return (
+    <Popover
+      open={open}
+      onOpenChange={(next) => {
+        setOpen(next)
+        if (!next) setSearch('')
+      }}
+    >
+      <PopoverTrigger
+        disabled={disabled}
+        data-testid={props['data-testid']}
+        className={cn(
+          "border-input data-[placeholder]:text-muted-foreground [&_svg:not([class*='text-'])]:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 dark:bg-input/30 dark:hover:bg-input/50 flex h-7 w-full items-center justify-between gap-1.5 rounded-md border bg-transparent px-2 py-1 text-xs whitespace-nowrap shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50",
+          triggerClassName,
+        )}
+        style={triggerStyle}
+      >
+        <span className='truncate'>{selectedLabel ?? placeholder ?? ''}</span>
+        <ChevronDownIcon className='size-3.5 shrink-0 opacity-50' />
+      </PopoverTrigger>
+      <PopoverContent
+        className={cn('w-(--radix-popover-trigger-width) p-0', className)}
+        align='start'
+        onOpenAutoFocus={(e) => {
+          e.preventDefault()
+          inputRef.current?.focus()
+        }}
+      >
+        <input
+          ref={inputRef}
+          value={search}
+          onChange={(e) => setSearch(e.target.value)}
+          placeholder='Search fonts…'
+          className='placeholder:text-muted-foreground w-full border-b bg-transparent px-2 py-1.5 text-xs outline-none'
+        />
+        <ScrollArea
+          className='relative'
+          style={{ height: listHeight }}
+          viewportRef={viewportRef}
+        >
+          <div
+            style={{
+              height: virtualizer.getTotalSize(),
+              position: 'relative',
+            }}
+          >
+            {virtualizer.getVirtualItems().map((vi) => {
+              const font = filtered[vi.index]
+              const selected =
+                font.postScriptName === value || font.familyName === value
+              return (
+                <button
+                  key={vi.key}
+                  type='button'
+                  className={cn(
+                    'hover:bg-accent hover:text-accent-foreground absolute left-0 flex w-full cursor-default items-center gap-1.5 rounded-sm px-2 text-xs select-none',
+                    selected && 'bg-accent',
+                  )}
+                  style={{
+                    height: ITEM_HEIGHT,
+                    top: vi.start,
+                    fontFamily: font.familyName,
+                  }}
+                  onClick={() => {
+                    onChange(font.postScriptName)
+                    setOpen(false)
+                    setSearch('')
+                  }}
+                >
+                  <span className='flex size-3 shrink-0 items-center justify-center'>
+                    {selected && <CheckIcon className='size-3' />}
+                  </span>
+                  <span className='truncate'>{font.familyName}</span>
+                </button>
+              )
+            })}
+          </div>
+        </ScrollArea>
+        {filtered.length === 0 && (
+          <div className='text-muted-foreground px-2 py-4 text-center text-xs'>
+            No fonts found
+          </div>
+        )}
+      </PopoverContent>
+    </Popover>
+  )
+}

ui/hooks/useBlobData.ts

@@ -23,7 +23,7 @@ export function useBlobData(hash: string | undefined): Uint8Array | undefined {
     enabled: !!hash,
     placeholderData: keepPreviousData,
   })
-  return data
+  return hash ? data : undefined
 }
 
 const blobImageQueryOptions = (hash: string) => ({

ui/hooks/useTextBlocks.ts

@@ -44,6 +44,10 @@ const mapTextBlock = (
   style: block.style as TextBlock['style'],
   fontPrediction: block.fontPrediction as TextBlock['fontPrediction'],
   rendered: block.rendered ?? undefined,
+  renderX: block.renderX ?? undefined,
+  renderY: block.renderY ?? undefined,
+  renderWidth: block.renderWidth ?? undefined,
+  renderHeight: block.renderHeight ?? undefined,
 })
 
 export type MappedDocument = {

ui/lib/api/schemas/textBlockDetail.ts

@@ -18,6 +18,17 @@ export interface TextBlockDetail {
   id: string
   /** @nullable */
   linePolygons?: number[][][] | null
+  /** @nullable */
+  renderHeight?: number | null
+  /** @nullable */
+  renderWidth?: number | null
+  /**
+   * Actual render area position/size (when bubble expansion is used).
+   * @nullable
+   */
+  renderX?: number | null
+  /** @nullable */
+  renderY?: number | null
   /**
    * Blob hash for the rendered text block sprite.
    * @nullable

ui/openapi.json

@@ -2381,6 +2381,23 @@
               }
             }
           },
+          "renderHeight": {
+            "type": ["number", "null"],
+            "format": "float"
+          },
+          "renderWidth": {
+            "type": ["number", "null"],
+            "format": "float"
+          },
+          "renderX": {
+            "type": ["number", "null"],
+            "format": "float",
+            "description": "Actual render area position/size (when bubble expansion is used)."
+          },
+          "renderY": {
+            "type": ["number", "null"],
+            "format": "float"
+          },
           "rendered": {
             "type": ["string", "null"],
             "description": "Blob hash for the rendered text block sprite."

ui/types.d.ts

@@ -69,6 +69,11 @@ export type TextBlock = {
   fontPrediction?: FontPrediction
   /** Blob hash for the rendered text block sprite. */
   rendered?: string
+  /** Actual render area (when bubble expansion is used). */
+  renderX?: number
+  renderY?: number
+  renderWidth?: number
+  renderHeight?: number
 }
 
 export type ToolMode = 'select' | 'block' | 'brush' | 'repairBrush' | 'eraser'