fix: global font family & disable image transition

koharu-renderer/src/facade.rs

@@ -146,14 +146,8 @@ impl Renderer {
             text_align: None,
         });
 
-        if let Some(ff) = font_family {
-            if !style.font_families.contains(&ff.to_string()) {
-                style.font_families.insert(0, ff.to_string());
-            } else {
-                style.font_families.retain(|x| x != ff);
-                style.font_families.insert(0, ff.to_string());
-            }
-        }
+        apply_global_font_family(&mut style.font_families, font_family);
+        apply_default_font_families(&mut style.font_families, &normalized_translation);
         let font = self.select_font(&style)?;
         let block_effect = style.effect.unwrap_or(effect);
         let color = text_block
@@ -294,6 +288,20 @@ fn default_stroke_width(font_size: f32) -> f32 {
     (font_size * 0.10).clamp(1.2, 8.0)
 }
 
+fn apply_global_font_family(font_families: &mut Vec<String>, font_family: Option<&str>) {
+    if font_families.is_empty()
+        && let Some(font_family) = font_family
+    {
+        font_families.push(font_family.to_string());
+    }
+}
+
+fn apply_default_font_families(font_families: &mut Vec<String>, text: &str) {
+    if font_families.is_empty() {
+        *font_families = font_families_for_text(text);
+    }
+}
+
 fn resolve_stroke_style(
     block: &TextBlock,
     block_stroke: Option<&TextStrokeStyle>,
@@ -427,7 +435,10 @@ fn load_symbol_fallbacks(fontbook: &mut FontBook) -> Vec<Font> {
 
 #[cfg(test)]
 mod tests {
-    use super::{align_layout_horizontally, center_layout_vertically};
+    use super::{
+        align_layout_horizontally, apply_default_font_families, apply_global_font_family,
+        center_layout_vertically,
+    };
     use crate::layout::{LayoutLine, LayoutRun, WritingMode};
     use koharu_types::TextAlign;
 
@@ -534,4 +545,26 @@ mod tests {
         assert_eq!(layout.lines[0].baseline.1, 32.0);
         assert_eq!(layout.height, 60.0);
     }
+
+    #[test]
+    fn explicit_block_font_should_not_be_overridden_by_global_font() {
+        let mut font_families = vec!["Block Font".to_string()];
+        apply_global_font_family(&mut font_families, Some("Global Font"));
+
+        assert_eq!(font_families, vec!["Block Font".to_string()]);
+    }
+
+    #[test]
+    fn global_font_should_fill_empty_block_font_list() {
+        let mut font_families = Vec::new();
+        apply_global_font_family(&mut font_families, Some("Global Font"));
+        assert_eq!(font_families, vec!["Global Font".to_string()]);
+    }
+
+    #[test]
+    fn default_font_families_should_fill_empty_list() {
+        let mut font_families = Vec::new();
+        apply_default_font_families(&mut font_families, "hello");
+        assert!(!font_families.is_empty());
+    }
 }

ui/components/canvas/Workspace.tsx

@@ -299,6 +299,7 @@ export function Workspace() {
                             data-testid='workspace-inpainted-image'
                             data={currentDocument.inpainted}
                             visible={showInpaintedImage}
+                            transition={false}
                           />
                         )}
                         <canvas
@@ -345,10 +346,11 @@ export function Workspace() {
                             style={{ zIndex: 30 }}
                           />
                         )}
-                        {currentDocument?.rendered && showRenderedImage && (
+                        {currentDocument.rendered && showRenderedImage && (
                           <Image
                             data-testid='workspace-rendered-image'
-                            data={currentDocument?.rendered}
+                            data={currentDocument.rendered}
+                            transition={false}
                             style={{ zIndex: 40 }}
                           />
                         )}

ui/components/panels/RenderControlsPanel.tsx

@@ -110,6 +110,27 @@ const normalizeStroke = (stroke?: Partial<RenderStroke>): RenderStroke => ({
   widthPx: stroke?.widthPx,
 })
 
+const resolveStyleColor = (
+  style: TextStyle | undefined,
+  block:
+    | {
+        fontPrediction?: {
+          text_color: [number, number, number]
+        }
+      }
+    | undefined,
+  fallbackColor: RgbaColor,
+): RgbaColor =>
+  style?.color ??
+  (block?.fontPrediction?.text_color
+    ? [
+        block.fontPrediction.text_color[0],
+        block.fontPrediction.text_color[1],
+        block.fontPrediction.text_color[2],
+        255,
+      ]
+    : fallbackColor)
+
 const resolveEffectiveTextAlign = (
   block:
     | {
@@ -159,8 +180,8 @@ export function RenderControlsPanel() {
         ]
   const fontOptions = uniqueStrings(fontCandidates)
   const currentFont =
-    fontFamily ??
     selectedBlock?.style?.fontFamilies?.[0] ??
+    fontFamily ??
     firstBlock?.style?.fontFamilies?.[0] ??
     (hasBlocks ? fallbackFontFamilies[0] : '')
   const currentEffect = normalizeEffect(
@@ -189,15 +210,35 @@ export function RenderControlsPanel() {
   const currentTextAlign = resolveEffectiveTextAlign(
     selectedBlock ?? firstBlock,
   )
+  const scopeLabel =
+    selectedBlockIndex !== undefined
+      ? t('render.fontScopeBlockIndex', {
+          index: selectedBlockIndex + 1,
+          defaultValue: `Block ${selectedBlockIndex + 1}`,
+        })
+      : t('render.fontScopeGlobal', {
+          defaultValue: 'Global',
+        })
+  const scopeToneClass =
+    selectedBlockIndex !== undefined
+      ? 'border-primary/20 bg-primary/10 text-primary'
+      : 'border-border/60 bg-muted text-muted-foreground'
 
   const buildStyle = (
+    block:
+      | {
+          style?: TextStyle
+          fontPrediction?: {
+            text_color: [number, number, number]
+          }
+        }
+      | undefined,
     style: TextStyle | undefined,
     updates: Partial<TextStyle>,
   ): TextStyle => ({
-    fontFamilies:
-      updates.fontFamilies ?? style?.fontFamilies ?? fallbackFontFamilies,
+    fontFamilies: updates.fontFamilies ?? style?.fontFamilies ?? [],
     fontSize: updates.fontSize ?? style?.fontSize,
-    color: updates.color ?? style?.color ?? fallbackColor,
+    color: updates.color ?? resolveStyleColor(style, block, fallbackColor),
     effect: updates.effect ?? style?.effect,
     stroke: updates.stroke ?? style?.stroke,
     textAlign: updates.textAlign ?? style?.textAlign,
@@ -205,7 +246,7 @@ export function RenderControlsPanel() {
 
   const applyStyleToSelected = (updates: Partial<TextStyle>) => {
     if (selectedBlockIndex === undefined) return false
-    const nextStyle = buildStyle(selectedBlock?.style, updates)
+    const nextStyle = buildStyle(selectedBlock, selectedBlock?.style, updates)
     void replaceBlock(selectedBlockIndex, { style: nextStyle })
     return true
   }
@@ -214,7 +255,7 @@ export function RenderControlsPanel() {
     if (!hasBlocks) return
     const nextBlocks = textBlocks.map((block) => ({
       ...block,
-      style: buildStyle(block.style, updates),
+      style: buildStyle(block, block.style, updates),
     }))
     void updateTextBlocks(nextBlocks)
   }
@@ -273,6 +314,18 @@ export function RenderControlsPanel() {
 
   return (
     <div className='flex w-full min-w-0 flex-col gap-1.5'>
+      <div className='flex items-center justify-end'>
+        <span
+          data-testid='render-scope-indicator'
+          className={cn(
+            'rounded-full border px-2 py-0.5 text-[10px] font-medium tracking-wide uppercase',
+            scopeToneClass,
+          )}
+        >
+          {scopeLabel}
+        </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}
@@ -283,16 +336,16 @@ export function RenderControlsPanel() {
             <Select
               value={currentFont}
               onValueChange={(value) => {
-                setFontFamily(value)
                 const nextFamilies = mergeFontFamilies(
                   value,
                   selectedBlock?.style?.fontFamilies,
                 )
                 if (applyStyleToSelected({ fontFamilies: nextFamilies })) return
+                setFontFamily(value)
                 if (!hasBlocks) return
                 const nextBlocks = textBlocks.map((block) => ({
                   ...block,
-                  style: buildStyle(block.style, {
+                  style: buildStyle(block, block.style, {
                     fontFamilies: mergeFontFamilies(
                       value,
                       block.style?.fontFamilies,