feat: google fonts

.gitignore

@@ -30,6 +30,8 @@ target/
 
 # Datasets
 data/
+!koharu-app/data/
+!koharu-app/data/google-fonts-catalog.json
 
 # model results
 runs/

koharu-app/src/engine.rs

@@ -933,7 +933,7 @@ struct KoharuRenderEngine;
 #[async_trait]
 impl Engine for KoharuRenderEngine {
     async fn run(&self, doc: &Document, res: &AppResources) -> Result<Patch> {
-        render_document(res, &doc.id, None, None, None, None).await?;
+        render_document(res, &doc.id, None, None, None).await?;
         Ok(Patch::none())
     }
 }
@@ -970,10 +970,10 @@ pub async fn render_document(
     text_block_index: Option<usize>,
     shader_effect: Option<TextShaderEffect>,
     shader_stroke: Option<TextStrokeStyle>,
-    font_family: Option<&str>,
 ) -> Result<()> {
     let renderer = get_renderer(res).await?;
     let doc = res.storage.page(document_id).await?;
+    let document_font = doc.style.as_ref().and_then(|s| s.default_font.as_deref());
     let source = res.storage.images.load(&doc.source)?;
     let inpainted = doc
         .inpainted
@@ -997,7 +997,7 @@ pub async fn render_document(
             text_block_index,
             shader_effect: shader_effect.unwrap_or_default(),
             shader_stroke,
-            font_family,
+            document_font,
             bubbles: &bubbles,
             image_width: doc.width,
             image_height: doc.height,

koharu-app/src/google_fonts.rs

@@ -0,0 +1,171 @@
+use std::collections::HashMap;
+
+use anyhow::{Context, Result};
+use camino::{Utf8Path, Utf8PathBuf};
+use koharu_core::{GoogleFontCatalog, GoogleFontEntry};
+use tokio::sync::Mutex;
+use tracing::debug;
+
+const CATALOG_JSON: &str = include_str!("../data/google-fonts-catalog.json");
+
+const RECOMMENDED_FAMILIES: &[&str] = &[
+    "Comic Neue",
+    "Bangers",
+    "Patrick Hand",
+    "Caveat",
+    "Pangolin",
+];
+
+/// On-demand Google Fonts service with persistent disk caching.
+pub struct GoogleFontService {
+    catalog: GoogleFontCatalog,
+    cache_dir: Utf8PathBuf,
+    /// Tracks which families have been downloaded to disk.
+    cached_families: Mutex<HashMap<String, Vec<Utf8PathBuf>>>,
+}
+
+impl GoogleFontService {
+    pub fn new(app_data_root: &Utf8Path) -> Result<Self> {
+        let catalog: GoogleFontCatalog =
+            serde_json::from_str(CATALOG_JSON).context("failed to parse Google Fonts catalog")?;
+        let cache_dir = app_data_root.join("fonts").join("google");
+        std::fs::create_dir_all(cache_dir.as_std_path())
+            .context("failed to create Google Fonts cache dir")?;
+
+        // Scan existing cache to populate known cached families
+        let mut cached_families = HashMap::new();
+        for entry in &catalog.fonts {
+            let family_dir = cache_dir.join(normalize_family_dir(&entry.family));
+            if family_dir.exists() {
+                let paths: Vec<Utf8PathBuf> = entry
+                    .variants
+                    .iter()
+                    .map(|v| family_dir.join(&v.filename))
+                    .filter(|p| p.exists())
+                    .collect();
+                if !paths.is_empty() {
+                    cached_families.insert(entry.family.clone(), paths);
+                }
+            }
+        }
+
+        Ok(Self {
+            catalog,
+            cache_dir,
+            cached_families: Mutex::new(cached_families),
+        })
+    }
+
+    /// Returns the full catalog for browsing.
+    pub fn catalog(&self) -> &GoogleFontCatalog {
+        &self.catalog
+    }
+
+    /// Returns the list of recommended font family names.
+    pub fn recommended_families(&self) -> &[&str] {
+        RECOMMENDED_FAMILIES
+    }
+
+    /// Checks if a family has been cached to disk.
+    pub async fn is_cached(&self, family: &str) -> bool {
+        self.cached_families.lock().await.contains_key(family)
+    }
+
+    /// Downloads a font family's regular variant to disk cache.
+    /// Returns the path to the cached .ttf file.
+    /// No-op if already cached.
+    pub async fn fetch_family(&self, family: &str, http: &reqwest_middleware::ClientWithMiddleware) -> Result<Utf8PathBuf> {
+        // Check cache first
+        {
+            let cached = self.cached_families.lock().await;
+            if let Some(first) = cached.get(family).and_then(|p| p.first()) {
+                return Ok(first.clone());
+            }
+        }
+
+        let entry = self
+            .catalog
+            .fonts
+            .iter()
+            .find(|e| e.family == family)
+            .with_context(|| format!("font family not found in catalog: {family}"))?;
+
+        // Prefer regular weight, fallback to first variant
+        let variant = entry
+            .variants
+            .iter()
+            .find(|v| v.weight == 400 && v.style == "normal")
+            .or_else(|| entry.variants.first())
+            .context("font has no variants")?;
+
+        let family_dir_name = normalize_family_dir(&entry.family);
+        let url = format!(
+            "https://raw.githubusercontent.com/google/fonts/main/ofl/{}/{}",
+            family_dir_name, variant.filename
+        );
+
+        debug!(%family, %url, "downloading Google Font");
+        let response = http
+            .get(&url)
+            .send()
+            .await
+            .context("failed to fetch Google Font")?
+            .error_for_status()
+            .context("Google Fonts CDN returned an error")?;
+        let bytes = response
+            .bytes()
+            .await
+            .context("failed to read font bytes")?;
+
+        // Write to disk cache
+        let family_dir = self.cache_dir.join(&family_dir_name);
+        std::fs::create_dir_all(family_dir.as_std_path())?;
+        let file_path = family_dir.join(&variant.filename);
+        std::fs::write(file_path.as_std_path(), &bytes)
+            .with_context(|| format!("failed to write cached font to {file_path}"))?;
+
+        // Update in-memory cache tracking
+        self.cached_families
+            .lock()
+            .await
+            .insert(family.to_string(), vec![file_path.clone()]);
+
+        Ok(file_path)
+    }
+
+    /// Reads the cached font file bytes. Returns None if not cached.
+    pub fn read_cached_file(&self, family: &str) -> Result<Option<Vec<u8>>> {
+        let entry = self.catalog.fonts.iter().find(|e| e.family == family);
+        let Some(entry) = entry else {
+            return Ok(None);
+        };
+        let variant = entry
+            .variants
+            .iter()
+            .find(|v| v.weight == 400 && v.style == "normal")
+            .or_else(|| entry.variants.first());
+        let Some(variant) = variant else {
+            return Ok(None);
+        };
+        let file_path = self
+            .cache_dir
+            .join(normalize_family_dir(&entry.family))
+            .join(&variant.filename);
+        if !file_path.exists() {
+            return Ok(None);
+        }
+        let data = std::fs::read(file_path.as_std_path()).context("failed to read cached font")?;
+        Ok(Some(data))
+    }
+
+    /// Find catalog entry by family name.
+    pub fn find_entry(&self, family: &str) -> Option<&GoogleFontEntry> {
+        self.catalog.fonts.iter().find(|e| e.family == family)
+    }
+}
+
+/// Converts family name to directory name (lowercase, spaces to empty).
+/// e.g. "Comic Neue" -> "comicneue"
+fn normalize_family_dir(family: &str) -> String {
+    family.to_lowercase().replace(' ', "")
+}

koharu-app/src/lib.rs

@@ -1,6 +1,7 @@
 pub mod config;
 pub mod edit;
 pub mod engine;
+pub mod google_fonts;
 pub mod io;
 pub mod llm;
 pub mod pipeline;

koharu-app/src/renderer.rs

@@ -1,9 +1,10 @@
 use std::sync::{Arc, Mutex};
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use image::{DynamicImage, imageops};
 use koharu_core::{
-    BlobRef, FontFaceInfo, TextAlign, TextBlock, TextShaderEffect, TextStrokeStyle, TextStyle,
+    BlobRef, FontFaceInfo, FontSource, TextAlign, TextBlock, TextShaderEffect, TextStrokeStyle,
+    TextStyle,
 };
 
 use koharu_renderer::{
@@ -19,6 +20,7 @@ use koharu_renderer::{
     },
 };
 
+use crate::google_fonts::GoogleFontService;
 use crate::storage;
 
 /// Grouped options for [`Renderer::render_to_blob`] to keep the arg count manageable.
@@ -26,7 +28,7 @@ pub struct RenderTextOptions<'a> {
     pub text_block_index: Option<usize>,
     pub shader_effect: TextShaderEffect,
     pub shader_stroke: Option<TextStrokeStyle>,
-    pub font_family: Option<&'a str>,
+    pub document_font: Option<&'a str>,
     pub bubbles: &'a [koharu_core::BubbleRegion],
     pub image_width: u32,
     pub image_height: u32,
@@ -135,16 +137,23 @@ pub struct Renderer {
     fontbook: Arc<Mutex<FontBook>>,
     renderer: TinySkiaRenderer,
     symbol_fallbacks: Vec<Font>,
+    pub google_fonts: Arc<GoogleFontService>,
 }
 
 impl Renderer {
     pub fn new() -> Result<Self> {
         let mut fontbook = FontBook::new();
         let symbol_fallbacks = load_symbol_fallbacks(&mut fontbook);
+        let app_data_root = koharu_runtime::default_app_data_root();
+        let google_fonts = Arc::new(
+            GoogleFontService::new(&app_data_root)
+                .context("failed to initialize Google Fonts service")?,
+        );
         Ok(Self {
             fontbook: Arc::new(Mutex::new(fontbook)),
             renderer: TinySkiaRenderer::new()?,
             symbol_fallbacks,
+            google_fonts,
         })
     }
 
@@ -168,12 +177,30 @@ impl Renderer {
                     Some(FontFaceInfo {
                         family_name,
                         post_script_name: face.post_script_name,
+                        source: FontSource::System,
+                        category: None,
+                        cached: true,
                     })
                 } else {
                     None
                 }
             })
             .collect::<Vec<_>>();
+
+        // Google Fonts (from catalog)
+        let catalog = self.google_fonts.catalog();
+        for entry in &catalog.fonts {
+            if seen.insert(entry.family.clone()) {
+                fonts.push(FontFaceInfo {
+                    family_name: entry.family.clone(),
+                    post_script_name: entry.family.clone(),
+                    source: FontSource::Google,
+                    category: Some(entry.category.clone()),
+                    cached: false,
+                });
+            }
+        }
+
         fonts.sort();
         Ok(fonts)
     }
@@ -229,7 +256,7 @@ impl Renderer {
                         text_block,
                         opts.shader_effect,
                         opts.shader_stroke.clone(),
-                        opts.font_family,
+                        opts.document_font,
                         bubble_area,
                         base_font_size,
                         min_font,
@@ -285,7 +312,7 @@ impl Renderer {
         text_block: &mut TextBlock,
         effect: TextShaderEffect,
         global_stroke: Option<TextStrokeStyle>,
-        font_family: Option<&str>,
+        document_font: Option<&str>,
         bubble_area: Option<LayoutBox>,
         base_font_size: Option<f32>,
         min_font_size: f32,
@@ -317,7 +344,12 @@ impl Renderer {
             text_align: None,
         });
 
-        apply_global_font_family(&mut style.font_families, font_family);
+        // Font cascade: per-block → document default → script fallback
+        if style.font_families.is_empty()
+            && let Some(font) = document_font
+        {
+            style.font_families.push(font.to_string());
+        }
         apply_default_font_families(&mut style.font_families, &normalized_translation);
         let font = {
             let _s = tracing::info_span!("select_font").entered();
@@ -420,7 +452,7 @@ impl Renderer {
             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 {
+        let _persisted_style = text_block.style.get_or_insert_with(|| TextStyle {
             font_families: Vec::new(),
             font_size: None,
             color,
@@ -428,7 +460,7 @@ impl Renderer {
             stroke: None,
             text_align: None,
         });
-        persisted_style.font_families = vec![font.post_script_name().to_string()];
+        // font_families is NOT set here — it only contains user-explicit choices
         Ok(Some(DynamicImage::ImageRgba8(rendered)))
     }
 
@@ -437,15 +469,29 @@ impl Renderer {
             .fontbook
             .lock()
             .map_err(|_| anyhow::anyhow!("Failed to lock fontbook"))?;
-        let faces = fontbook.all_families();
-        let post_script_name = style
-            .font_families
-            .iter()
-            .find_map(|candidate| face_post_script_name(&faces, candidate))
-            .ok_or_else(|| {
-                anyhow::anyhow!("no font found for candidates: {:?}", style.font_families)
-            })?;
-        fontbook.query(&post_script_name)
+
+        // Try each candidate through the full resolution chain before moving
+        // to the next.  This ensures a global font (first in the list) is
+        // resolved from the disk cache even when a previously-loaded font
+        // appears later in the list.
+        for candidate in &style.font_families {
+            // Already loaded in FontBook (system font or previously loaded Google Font)?
+            let faces = fontbook.all_families();
+            if let Some(psn) = face_post_script_name(&faces, candidate) {
+                return fontbook.query(&psn);
+            }
+
+            // Try Google Fonts disk cache
+            if let Some(data) = self.google_fonts.read_cached_file(candidate)? {
+                let font = fontbook.load_from_bytes(data)?;
+                return Ok(font);
+            }
+        }
+
+        Err(anyhow::anyhow!(
+            "no font found for candidates: {:?}",
+            style.font_families
+        ))
     }
 }
 
@@ -453,14 +499,6 @@ 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);
@@ -705,8 +743,8 @@ fn find_best_bubble(block: &TextBlock, bubbles: &[koharu_core::BubbleRegion]) ->
 #[cfg(test)]
 mod tests {
     use super::{
-        align_layout_horizontally, apply_default_font_families, apply_global_font_family,
-        center_layout_vertically, resolve_stroke_style,
+        align_layout_horizontally, apply_default_font_families, center_layout_vertically,
+        resolve_stroke_style,
     };
     use koharu_core::{FontPrediction, TextAlign, TextBlock, TextStrokeStyle};
     use koharu_renderer::layout::{LayoutLine, LayoutRun, WritingMode};
@@ -815,21 +853,6 @@ mod tests {
         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();
@@ -837,15 +860,6 @@ mod tests {
         assert!(!font_families.is_empty());
     }
 
-    #[test]
-    fn global_font_should_be_applied_before_default_script_fonts() {
-        let mut font_families = Vec::new();
-        apply_global_font_family(&mut font_families, Some("Global Font"));
-        apply_default_font_families(&mut font_families, "hello");
-
-        assert_eq!(font_families, vec!["Global Font".to_string()]);
-    }
-
     #[test]
     fn default_stroke_color_uses_black_for_light_text() {
         let stroke = resolve_stroke_style(

koharu-core/src/commands.rs

@@ -74,7 +74,6 @@ pub struct ProcessRequest {
     pub language: Option<String>,
     pub shader_effect: Option<TextShaderEffect>,
     pub shader_stroke: Option<TextStrokeStyle>,
-    pub font_family: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
@@ -112,7 +111,6 @@ pub struct RenderParams {
     pub document_id: String,
     pub text_block_index: Option<usize>,
     pub shader_effect: Option<String>,
-    pub font_family: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
@@ -128,7 +126,6 @@ pub struct ProcessParams {
     pub llm_target: Option<crate::LlmTarget>,
     pub language: Option<String>,
     pub shader_effect: Option<String>,
-    pub font_family: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
@@ -283,7 +280,6 @@ mod tests {
                 color: [255, 255, 255, 255],
                 width_px: Some(2.0),
             }),
-            font_family: Some("Noto Sans".to_string()),
         });
         round_trip(&ViewImageParams {
             document_id: "abc123".to_string(),
@@ -306,7 +302,6 @@ mod tests {
             document_id: "abc123".to_string(),
             text_block_index: Some(0),
             shader_effect: Some("bold".to_string()),
-            font_family: Some("Noto Sans".to_string()),
         });
         round_trip(&ProcessParams {
             document_id: Some("abc123".to_string()),
@@ -317,7 +312,6 @@ mod tests {
             }),
             language: Some("zh-CN".to_string()),
             shader_effect: Some("italic,bold".to_string()),
-            font_family: Some("Noto Sans".to_string()),
         });
         round_trip(&UpdateTextBlockPayload {
             index: 1,

koharu-core/src/google_fonts.rs

@@ -0,0 +1,34 @@
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GoogleFontVariant {
+    pub style: String,
+    pub weight: u16,
+    pub filename: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GoogleFontEntry {
+    pub family: String,
+    pub category: String,
+    pub subsets: Vec<String>,
+    pub variants: Vec<GoogleFontVariant>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GoogleFontCatalog {
+    pub fonts: Vec<GoogleFontEntry>,
+}
+
+#[derive(
+    Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, JsonSchema, ToSchema,
+)]
+#[serde(rename_all = "snake_case")]
+pub enum FontSource {
+    System,
+    Google,
+}

koharu-core/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod commands;
 pub mod events;
+pub mod google_fonts;
 pub mod parse;
 pub mod protocol;
 pub mod views;
@@ -12,6 +13,7 @@ pub use commands::*;
 pub use effect::TextShaderEffect;
 pub use events::*;
 pub use font::{FontPrediction, NamedFontPrediction, TextDirection, TopFont};
+pub use google_fonts::{FontSource, GoogleFontCatalog, GoogleFontEntry, GoogleFontVariant};
 pub use image::SerializableDynamicImage;
 pub use protocol::*;
 
@@ -175,6 +177,13 @@ pub struct BubbleRegion {
     pub confidence: f32,
 }
 
+#[derive(Default, Debug, Clone, Serialize, Deserialize, ToSchema, JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct DocumentStyle {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub default_font: Option<String>,
+}
+
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Document {
@@ -190,6 +199,8 @@ pub struct Document {
     pub text_blocks: Vec<TextBlock>,
     #[serde(default)]
     pub bubbles: Vec<BubbleRegion>,
+    #[serde(default)]
+    pub style: Option<DocumentStyle>,
 }
 #[cfg(test)]
 mod tests {}

koharu-core/src/protocol.rs

@@ -11,6 +11,10 @@ use crate::{FontPrediction, TextBlock, TextShaderEffect, TextStrokeStyle, TextSt
 pub struct FontFaceInfo {
     pub family_name: String,
     pub post_script_name: String,
+    pub source: crate::google_fonts::FontSource,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub category: Option<String>,
+    pub cached: bool,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
@@ -119,6 +123,8 @@ pub struct DocumentDetail {
     /// Blob hash for the rendered composite layer.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub rendered: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub style: Option<crate::DocumentStyle>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
@@ -339,7 +345,6 @@ pub struct RenderRequest {
     pub text_block_id: Option<String>,
     pub shader_effect: Option<TextShaderEffect>,
     pub shader_stroke: Option<TextStrokeStyle>,
-    pub font_family: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]
@@ -365,7 +370,6 @@ pub struct PipelineJobRequest {
     pub language: Option<String>,
     pub shader_effect: Option<TextShaderEffect>,
     pub shader_stroke: Option<TextStrokeStyle>,
-    pub font_family: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, ToSchema)]

koharu-renderer/src/font.rs

@@ -124,6 +124,19 @@ impl FontBook {
         self.load_font(id)
     }
 
+    /// Loads a font from raw bytes (e.g., downloaded from Google Fonts).
+    /// Returns the loaded Font on success.
+    pub fn load_from_bytes(&mut self, data: Vec<u8>) -> anyhow::Result<Font> {
+        let data: Arc<dyn AsRef<[u8]> + Send + Sync> = Arc::new(data);
+        let source = fontdb::Source::Binary(data);
+        let ids = self.database.load_font_source(source);
+        let id = ids
+            .into_iter()
+            .next()
+            .context("font data contained no valid faces")?;
+        self.load_font(id)
+    }
+
     fn load_font(&mut self, id: ID) -> anyhow::Result<Font> {
         if let Some(font) = self.cache.get(&id) {
             return Ok(font.clone());

koharu-renderer/src/text/script.rs

@@ -73,12 +73,12 @@ pub fn font_families_for_text(text: &str) -> Vec<String> {
             &["Noto Sans"]
         }
     } else {
+        // Google Fonts candidates (downloaded on demand) + platform fallbacks
         #[cfg(target_os = "windows")]
         {
             &[
-                "CC Wild Words",
-                "Wild Words",
-                "Anime Ace 2.0 BB",
+                "Comic Neue",
+                "Bangers",
                 "Comic Sans MS",
                 "Trebuchet MS",
                 "Segoe UI",
@@ -88,9 +88,8 @@ pub fn font_families_for_text(text: &str) -> Vec<String> {
         #[cfg(target_os = "macos")]
         {
             &[
-                "CC Wild Words",
-                "Wild Words",
-                "Anime Ace 2.0 BB",
+                "Comic Neue",
+                "Bangers",
                 "Chalkboard SE",
                 "Noteworthy",
                 "SF Pro",
@@ -100,10 +99,8 @@ pub fn font_families_for_text(text: &str) -> Vec<String> {
         #[cfg(not(any(target_os = "windows", target_os = "macos")))]
         {
             &[
-                "CC Wild Words",
-                "Wild Words",
-                "Anime Ace 2.0 BB",
                 "Comic Neue",
+                "Bangers",
                 "Noto Sans",
                 "DejaVu Sans",
                 "Liberation Sans",

koharu-rpc/src/api.rs

@@ -42,6 +42,7 @@ pub fn api() -> (axum::Router<ApiState>, utoipa::openapi::OpenApi) {
     OpenApiRouter::default()
         .routes(routes!(list_documents, import_documents))
         .routes(routes!(get_document))
+        .routes(routes!(update_document_style))
         .routes(routes!(get_blob))
         .routes(routes!(get_document_thumbnail))
         .routes(routes!(detect_document))
@@ -64,6 +65,8 @@ pub fn api() -> (axum::Router<ApiState>, utoipa::openapi::OpenApi) {
         .routes(routes!(list_downloads))
         .routes(routes!(get_meta))
         .routes(routes!(list_fonts))
+        .routes(routes!(get_google_fonts_catalog))
+        .routes(routes!(fetch_google_font, get_google_font_file))
         .routes(routes!(get_config, update_config))
         .routes(routes!(get_engine_catalog))
         .split_for_parts()
@@ -254,6 +257,154 @@ async fn list_fonts(State(state): State<ApiState>) -> ApiResult<Json<Vec<FontFac
     Ok(Json(fonts))
 }
 
+// ---------------------------------------------------------------------------
+// Google Fonts
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+struct GoogleFontCatalogResponse {
+    fonts: Vec<GoogleFontCatalogEntry>,
+    recommended: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+struct GoogleFontCatalogEntry {
+    family: String,
+    category: String,
+    subsets: Vec<String>,
+    cached: bool,
+}
+
+#[utoipa::path(
+    get,
+    path = "/fonts/google/catalog",
+    operation_id = "getGoogleFontsCatalog",
+    tag = "system",
+    responses(
+        (status = 200, body = GoogleFontCatalogResponse),
+        (status = 503, body = ApiError),
+    ),
+)]
+async fn get_google_fonts_catalog(
+    State(state): State<ApiState>,
+) -> ApiResult<Json<GoogleFontCatalogResponse>> {
+    let resources = state.resources()?;
+    let renderer = engine::get_renderer(&resources)
+        .await
+        .map_err(ApiError::from)?;
+    let service = &renderer.google_fonts;
+    let catalog = service.catalog();
+
+    let mut fonts = Vec::with_capacity(catalog.fonts.len());
+    for entry in &catalog.fonts {
+        fonts.push(GoogleFontCatalogEntry {
+            family: entry.family.clone(),
+            category: entry.category.clone(),
+            subsets: entry.subsets.clone(),
+            cached: service.is_cached(&entry.family).await,
+        });
+    }
+
+    let recommended = service
+        .recommended_families()
+        .iter()
+        .map(|s| s.to_string())
+        .collect();
+
+    Ok(Json(GoogleFontCatalogResponse { fonts, recommended }))
+}
+
+#[utoipa::path(
+    post,
+    path = "/fonts/google/{family}/fetch",
+    operation_id = "fetchGoogleFont",
+    tag = "system",
+    params(
+        ("family" = String, Path, description = "Font family name"),
+    ),
+    responses(
+        (status = 200, body = FontFaceInfo),
+        (status = 404, body = ApiError),
+        (status = 503, body = ApiError),
+    ),
+)]
+async fn fetch_google_font(
+    State(state): State<ApiState>,
+    Path(family): Path<String>,
+) -> ApiResult<Json<FontFaceInfo>> {
+    let resources = state.resources()?;
+    let renderer = engine::get_renderer(&resources)
+        .await
+        .map_err(ApiError::from)?;
+    let service = &renderer.google_fonts;
+
+    let entry = service.find_entry(&family).ok_or_else(|| {
+        ApiError::new(
+            StatusCode::NOT_FOUND,
+            format!("font family not found: {family}"),
+        )
+    })?;
+
+    let http = resources.runtime.http_client();
+    service
+        .fetch_family(&family, &http)
+        .await
+        .map_err(ApiError::from)?;
+
+    let category = Some(entry.category.clone());
+
+    Ok(Json(FontFaceInfo {
+        family_name: family.clone(),
+        post_script_name: family,
+        source: koharu_core::FontSource::Google,
+        category,
+        cached: true,
+    }))
+}
+
+#[utoipa::path(
+    get,
+    path = "/fonts/google/{family}/file",
+    operation_id = "getGoogleFontFile",
+    tag = "system",
+    params(
+        ("family" = String, Path, description = "Font family name"),
+    ),
+    responses(
+        (status = 200, description = "Font file bytes", content_type = "font/ttf"),
+        (status = 404, body = ApiError),
+        (status = 503, body = ApiError),
+    ),
+)]
+async fn get_google_font_file(
+    State(state): State<ApiState>,
+    Path(family): Path<String>,
+) -> Result<Response, ApiError> {
+    let resources = state.resources()?;
+    let renderer = engine::get_renderer(&resources)
+        .await
+        .map_err(ApiError::from)?;
+    let service = &renderer.google_fonts;
+
+    let data = service
+        .read_cached_file(&family)
+        .map_err(ApiError::from)?
+        .ok_or_else(|| {
+            ApiError::new(
+                StatusCode::NOT_FOUND,
+                format!("font not cached: {family}. Call fetch first."),
+            )
+        })?;
+
+    Ok(Response::builder()
+        .status(StatusCode::OK)
+        .header(CONTENT_TYPE, HeaderValue::from_static("font/ttf"))
+        .body(Body::from(data))
+        .unwrap())
+}
+
 // ---------------------------------------------------------------------------
 // Documents
 // ---------------------------------------------------------------------------
@@ -274,6 +425,45 @@ async fn list_documents(State(state): State<ApiState>) -> ApiResult<Json<Vec<Doc
     Ok(Json(documents))
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+struct UpdateDocumentStyleRequest {
+    #[serde(default)]
+    pub default_font: Option<String>,
+}
+
+#[utoipa::path(
+    patch,
+    path = "/documents/{document_id}/style",
+    operation_id = "updateDocumentStyle",
+    tag = "documents",
+    params(
+        ("document_id" = String, Path, description = "Document ID"),
+    ),
+    request_body = UpdateDocumentStyleRequest,
+    responses(
+        (status = 200, body = UpdateDocumentStyleRequest),
+        (status = 404, body = ApiError),
+        (status = 503, body = ApiError),
+    ),
+)]
+async fn update_document_style(
+    State(state): State<ApiState>,
+    Path(document_id): Path<String>,
+    Json(request): Json<UpdateDocumentStyleRequest>,
+) -> ApiResult<Json<UpdateDocumentStyleRequest>> {
+    let resources = state.resources()?;
+    resources
+        .storage
+        .update_page(&document_id, |doc| {
+            let style = doc.style.get_or_insert_with(Default::default);
+            style.default_font = request.default_font.clone();
+        })
+        .await
+        .map_err(ApiError::from)?;
+    Ok(Json(request))
+}
+
 #[utoipa::path(
     get,
     path = "/documents/{document_id}",
@@ -311,6 +501,7 @@ async fn get_document(
         inpainted: doc.inpainted.as_ref().map(|r| r.hash().to_string()),
         brush_layer: doc.brush_layer.as_ref().map(|r| r.hash().to_string()),
         rendered: doc.rendered.as_ref().map(|r| r.hash().to_string()),
+        style: doc.style.clone(),
     };
 
     Ok(Json(detail))
@@ -533,7 +724,6 @@ async fn render_document(
         text_block_index,
         request.shader_effect,
         request.shader_stroke,
-        request.font_family.as_deref(),
     )
     .await?;
 
@@ -829,7 +1019,7 @@ async fn patch_text_block(
         .map_err(ApiError::from)?;
 
     if needs_render && let Some(idx) = block_index {
-        engine::render_document(&resources, &document_id, Some(idx), None, None, None)
+        engine::render_document(&resources, &document_id, Some(idx), None, None)
             .await
             .map_err(ApiError::internal)?;
     }
@@ -1001,7 +1191,6 @@ async fn start_pipeline(
             language: request.language,
             shader_effect: request.shader_effect,
             shader_stroke: request.shader_stroke,
-            font_family: request.font_family,
         },
         state.tracker.jobs(),
     )

koharu-rpc/src/mcp/mod.rs

@@ -378,16 +378,9 @@ impl KoharuMcp {
             .transpose()
             .map_err(|e: anyhow::Error| e.to_string())?;
 
-        engine::render_document(
-            &res,
-            &p.document_id,
-            p.text_block_index,
-            effect,
-            None,
-            p.font_family.as_deref(),
-        )
-        .await
-        .map_err(|e| e.to_string())?;
+        engine::render_document(&res, &p.document_id, p.text_block_index, effect, None)
+            .await
+            .map_err(|e| e.to_string())?;
 
         Ok("Render complete".to_string())
     }
@@ -482,7 +475,6 @@ impl KoharuMcp {
                 language: p.language,
                 shader_effect: effect,
                 shader_stroke: None,
-                font_family: p.font_family,
             },
             jobs,
         )

ui/components/MenuBar.tsx

@@ -40,7 +40,6 @@ import {
 import { SettingsDialog, type TabId } from '@/components/SettingsDialog'
 import { useProcessing } from '@/lib/machines'
 import { useEditorUiStore } from '@/lib/stores/editorUiStore'
-import { usePreferencesStore } from '@/lib/stores/preferencesStore'
 import type { PipelineJobRequest } from '@/lib/api/schemas'
 
 type MenuItem = {
@@ -69,14 +68,12 @@ export function MenuBar() {
   const buildPipelineRequest = (documentId?: string): PipelineJobRequest => {
     const { selectedTarget, selectedLanguage, renderEffect, renderStroke } =
       useEditorUiStore.getState()
-    const { fontFamily } = usePreferencesStore.getState()
     return {
       documentId,
       llm: selectedTarget ? { target: selectedTarget } : undefined,
       language: selectedLanguage,
       shaderEffect: renderEffect,
       shaderStroke: renderStroke,
-      fontFamily,
     }
   }
 

ui/components/SettingsDialog.tsx

@@ -56,7 +56,6 @@ import {
   updateConfig,
 } from '@/lib/api/system/system'
 import { getLlmCatalog, getGetLlmCatalogQueryKey } from '@/lib/api/llm/llm'
-import { usePreferencesStore } from '@/lib/stores/preferencesStore'
 import { supportedLanguages } from '@/lib/i18n'
 import type {
   UpdateConfigBody,
@@ -405,9 +404,6 @@ function AppearancePane() {
   const { t, i18n } = useTranslation()
   const { theme, setTheme } = useTheme()
   const locales = useMemo(() => supportedLanguages, [])
-  const fontFamily = usePreferencesStore((s) => s.fontFamily)
-  const setFontFamily = usePreferencesStore((s) => s.setFontFamily)
-
   return (
     <div className='space-y-8'>
       <Section title={t('settings.theme')}>
@@ -443,18 +439,6 @@ function AppearancePane() {
           </SelectContent>
         </Select>
       </Section>
-
-      <Section
-        title={t('settings.renderingFont')}
-        description={t('settings.renderingFontDescription')}
-      >
-        <Input
-          type='text'
-          value={fontFamily ?? ''}
-          onChange={(e) => setFontFamily(e.target.value || undefined)}
-          placeholder='e.g. Noto Sans CJK'
-        />
-      </Section>
     </div>
   )
 }

ui/components/canvas/CanvasToolbar.tsx

@@ -38,7 +38,6 @@ import type {
   LlmProviderCatalog,
 } from '@/lib/api/schemas'
 import { useProcessing } from '@/lib/machines'
-import { usePreferencesStore } from '@/lib/stores/preferencesStore'
 import { llmTargetKey, sameLlmTarget } from '@/lib/llmTargets'
 import i18n from '@/lib/i18n'
 
@@ -194,14 +193,12 @@ function WorkflowButtons() {
         onClick={() => {
           const documentId = requireDocumentId()
           const { renderEffect, renderStroke } = useEditorUiStore.getState()
-          const { fontFamily } = usePreferencesStore.getState()
           send({
             type: 'START_RENDER',
             documentId,
             options: {
               shaderEffect: renderEffect,
               shaderStroke: renderStroke,
-              fontFamily,
             },
           })
         }}

ui/components/panels/RenderControlsPanel.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import type { ComponentType } from 'react'
+import { type ComponentType, useMemo } from 'react'
 import { useTranslation } from 'react-i18next'
 import {
   AlignCenterIcon,
@@ -31,8 +31,8 @@ import {
 } from '@/components/ui/tooltip'
 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'
+import { useListFonts, useGetGoogleFontsCatalog } from '@/lib/api/system/system'
+import { updateDocumentStyle } from '@/lib/api/documents/documents'
 import { cn } from '@/lib/utils'
 
 const DEFAULT_COLOR: RgbaColor = [0, 0, 0, 255]
@@ -40,6 +40,8 @@ const DEFAULT_FONT_FACES: FontFaceInfo[] = [
   {
     familyName: 'Arial',
     postScriptName: 'ArialMT',
+    source: 'system',
+    cached: true,
   },
 ]
 const DEFAULT_EFFECT: RenderEffect = {
@@ -117,6 +119,8 @@ const fallbackFontFace = (value?: string): FontFaceInfo | undefined => {
   return {
     familyName: normalized,
     postScriptName: normalized,
+    source: 'system',
+    cached: true,
   }
 }
 
@@ -177,10 +181,26 @@ export function RenderControlsPanel() {
   const setRenderEffect = useEditorUiStore((state) => state.setRenderEffect)
   const setRenderStroke = useEditorUiStore((state) => state.setRenderStroke)
   const { data: availableFonts = [] } = useListFonts()
-  const fontFamily = usePreferencesStore((state) => state.fontFamily)
-  const setFontFamily = usePreferencesStore((state) => state.setFontFamily)
-  const { textBlocks, selectedBlockIndex, replaceBlock, updateTextBlocks } =
-    useTextBlocks()
+  const { data: catalog } = useGetGoogleFontsCatalog()
+  const sortedFonts = useMemo(() => {
+    if (!availableFonts) return []
+    const recommended = new Set(catalog?.recommended ?? [])
+    return [...availableFonts].sort((a, b) => {
+      const aRec = recommended.has(a.familyName) ? 0 : 1
+      const bRec = recommended.has(b.familyName) ? 0 : 1
+      if (aRec !== bRec) return aRec - bRec
+      return a.familyName.localeCompare(b.familyName)
+    })
+  }, [availableFonts, catalog])
+  const {
+    document: currentDocument,
+    textBlocks,
+    selectedBlockIndex,
+    replaceBlock,
+    updateTextBlocks,
+  } = useTextBlocks()
+  const documentId = currentDocument?.id
+  const documentFont = currentDocument?.style?.defaultFont ?? undefined
   const { t } = useTranslation()
   const selectedBlock =
     selectedBlockIndex !== undefined
@@ -190,8 +210,8 @@ export function RenderControlsPanel() {
   const hasBlocks = textBlocks.length > 0
   const fontCandidates = uniqueFontFaces(
     [
-      ...availableFonts,
-      ...(fontFamily ? [fallbackFontFace(fontFamily)] : []),
+      ...sortedFonts,
+      ...(documentFont ? [fallbackFontFace(documentFont)] : []),
       ...(selectedBlock?.style?.fontFamilies
         ?.slice(0, 1)
         ?.map(fallbackFontFace) ?? []),
@@ -206,7 +226,7 @@ export function RenderControlsPanel() {
   const fontOptions = fontCandidates
   const currentFontCandidate =
     selectedBlock?.style?.fontFamilies?.[0] ??
-    fontFamily ??
+    documentFont ??
     firstBlock?.style?.fontFamilies?.[0] ??
     (hasBlocks ? fallbackFontFaces[0]?.postScriptName : '')
   const currentFontFace =
@@ -386,21 +406,23 @@ export function RenderControlsPanel() {
                   selectedBlock?.style?.fontFamilies,
                 )
                 if (applyStyleToSelected({ fontFamilies: nextFamilies })) return
-                setFontFamily(value)
-                if (!hasBlocks) return
-                const nextBlocks = textBlocks.map((block) => ({
-                  ...block,
-                  style: buildStyle(block, block.style, {
-                    fontFamilies: mergeFontFamilies(
-                      value,
-                      block.style?.fontFamilies,
-                    ),
-                  }),
-                }))
-                void updateTextBlocks(nextBlocks)
+                // Set as document default font
+                if (documentId) {
+                  void updateDocumentStyle(documentId, { defaultFont: value })
+                }
               }}
             />
           </div>
+          {selectedBlock?.style?.fontFamilies?.length ? (
+            <button
+              type='button'
+              className='text-muted-foreground hover:text-foreground text-[9px]'
+              onClick={() => applyStyleToSelected({ fontFamilies: [] })}
+              title='Reset to document default'
+            >
+              ✕
+            </button>
+          ) : null}
           <ColorPicker
             value={currentColorHex}
             disabled={!hasBlocks}

ui/components/panels/TextBlocksPanel.tsx

@@ -7,7 +7,6 @@ import { Languages, LoaderCircleIcon, Trash2Icon } from 'lucide-react'
 import { useTextBlocks } from '@/hooks/useTextBlocks'
 import { useGetLlm } from '@/lib/api/llm/llm'
 import { useEditorUiStore } from '@/lib/stores/editorUiStore'
-import { usePreferencesStore } from '@/lib/stores/preferencesStore'
 import { useProcessing } from '@/lib/machines'
 import {
   Accordion,
@@ -56,7 +55,6 @@ export function TextBlocksPanel() {
     const selectedLanguage = useEditorUiStore.getState().selectedLanguage
     const textBlockId = document.textBlocks[blockIndex]?.id
     const { renderEffect, renderStroke } = useEditorUiStore.getState()
-    const { fontFamily } = usePreferencesStore.getState()
     send({
       type: 'START_TRANSLATE_BLOCK',
       documentId,
@@ -67,7 +65,6 @@ export function TextBlocksPanel() {
       renderOptions: {
         shaderEffect: renderEffect,
         shaderStroke: renderStroke,
-        fontFamily,
       },
     })
   }

ui/components/ui/font-select.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { useRef, useState, useMemo, useCallback } from 'react'
+import { useRef, useState, useMemo, useCallback, useEffect } from 'react'
 import { useVirtualizer } from '@tanstack/react-virtual'
 import { CheckIcon, ChevronDownIcon } from 'lucide-react'
 import {
@@ -8,8 +8,9 @@ import {
   PopoverContent,
   PopoverTrigger,
 } from '@/components/ui/popover'
-import { ScrollArea } from '@/components/ui/scroll-area'
+import { ScrollArea, ScrollBar } from '@/components/ui/scroll-area'
 import { cn } from '@/lib/utils'
+import { fetchGoogleFont } from '@/lib/api/system/system'
 
 const ITEM_HEIGHT = 28
 const MAX_VISIBLE = 10
@@ -17,8 +18,13 @@ const MAX_VISIBLE = 10
 type FontOption = {
   familyName: string
   postScriptName: string
+  source: 'system' | 'google'
+  category?: string | null
+  cached: boolean
 }
 
+type FontLoadState = 'idle' | 'loading' | 'ready' | 'error'
+
 type FontSelectProps = {
   value: string
   options: FontOption[]
@@ -31,6 +37,93 @@ type FontSelectProps = {
   'data-testid'?: string
 }
 
+function useGoogleFontPreview(
+  family: string,
+  source: string,
+  isVisible: boolean,
+) {
+  const [state, setState] = useState<FontLoadState>(
+    source === 'system' ? 'ready' : 'idle',
+  )
+  const stateRef = useRef(state)
+  stateRef.current = state
+
+  useEffect(() => {
+    if (source !== 'google' || !isVisible || stateRef.current !== 'idle') return
+
+    let cancelled = false
+    setState('loading')
+
+    fetchGoogleFont(encodeURIComponent(family))
+      .then(() => {
+        if (cancelled) return
+        const url = `/api/v1/fonts/google/${encodeURIComponent(family)}/file`
+        const face = new FontFace(family, `url(${url})`)
+        return face.load()
+      })
+      .then((face) => {
+        if (cancelled || !face) return
+        document.fonts.add(face)
+        setState('ready')
+      })
+      .catch(() => {
+        if (!cancelled) setState('error')
+      })
+
+    return () => {
+      cancelled = true
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [family, source, isVisible])
+
+  return state
+}
+
+function FontRow({
+  font,
+  selected,
+  style,
+  isVisible,
+  onClick,
+}: {
+  font: FontOption
+  selected: boolean
+  style: React.CSSProperties
+  isVisible: boolean
+  onClick: () => void
+}) {
+  const loadState = useGoogleFontPreview(
+    font.familyName,
+    font.source,
+    isVisible,
+  )
+
+  return (
+    <button
+      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={{
+        ...style,
+        fontFamily: loadState === 'ready' ? font.familyName : undefined,
+      }}
+      onClick={onClick}
+    >
+      <span className='flex size-3 shrink-0 items-center justify-center'>
+        {selected && <CheckIcon className='size-3' />}
+      </span>
+      <span className='truncate'>{font.familyName}</span>
+      {font.source === 'google' && (
+        <span className='text-muted-foreground ml-auto shrink-0 text-[9px]'>
+          {loadState === 'loading' ? '...' : 'G'}
+        </span>
+      )}
+    </button>
+  )
+}
+
 export function FontSelect({
   value,
   options,
@@ -44,14 +137,23 @@ export function FontSelect({
 }: FontSelectProps) {
   const [open, setOpen] = useState(false)
   const [search, setSearch] = useState('')
+  const [categoryFilter, setCategoryFilter] = useState<string | null>(null)
   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])
+    let result = options
+    if (categoryFilter) {
+      result = result.filter(
+        (f) => f.source === 'system' || f.category === categoryFilter,
+      )
+    }
+    if (search) {
+      const lower = search.toLowerCase()
+      result = result.filter((f) => f.familyName.toLowerCase().includes(lower))
+    }
+    return result
+  }, [options, search, categoryFilter])
 
   const virtualizer = useVirtualizer({
     count: filtered.length,
@@ -111,6 +213,42 @@ export function FontSelect({
           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='border-b'>
+          <div className='flex gap-0.5 px-1.5 py-1'>
+            {['all', 'hand', 'display', 'sans', 'serif', 'mono'].map(
+              (cat, i) => {
+                const full = [
+                  'all',
+                  'handwriting',
+                  'display',
+                  'sans-serif',
+                  'serif',
+                  'monospace',
+                ][i]
+                const active =
+                  cat === 'all' ? !categoryFilter : categoryFilter === full
+                return (
+                  <button
+                    key={cat}
+                    type='button'
+                    className={cn(
+                      'shrink-0 rounded-full px-1.5 py-px text-[9px]',
+                      active
+                        ? 'bg-primary text-primary-foreground'
+                        : 'bg-muted text-muted-foreground hover:bg-accent',
+                    )}
+                    onClick={() =>
+                      setCategoryFilter(cat === 'all' ? null : full)
+                    }
+                  >
+                    {cat.charAt(0).toUpperCase() + cat.slice(1)}
+                  </button>
+                )
+              },
+            )}
+          </div>
+          <ScrollBar orientation='horizontal' />
+        </ScrollArea>
         <ScrollArea
           className='relative'
           style={{ height: listHeight }}
@@ -127,29 +265,18 @@ export function FontSelect({
               const selected =
                 font.postScriptName === value || font.familyName === value
               return (
-                <button
+                <FontRow
                   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,
-                  }}
+                  font={font}
+                  selected={selected}
+                  style={{ height: ITEM_HEIGHT, top: vi.start }}
+                  isVisible={true}
                   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>

ui/hooks/useTextBlocks.ts

@@ -62,6 +62,7 @@ export type MappedDocument = {
   inpainted?: string
   brushLayer?: string
   rendered?: string
+  style?: { defaultFont?: string | null }
 }
 
 const mapDocumentDetail = (detail: DocumentDetail): MappedDocument => ({
@@ -75,6 +76,7 @@ const mapDocumentDetail = (detail: DocumentDetail): MappedDocument => ({
   inpainted: detail.inpainted ?? undefined,
   brushLayer: detail.brushLayer ?? undefined,
   rendered: detail.rendered ?? undefined,
+  style: detail.style ?? undefined,
 })
 
 const toTextBlockInput = (block: TextBlock): TextBlockInput => ({

ui/lib/api/documents/documents.ts

@@ -27,6 +27,7 @@ import type {
   ImportDocumentsBody,
   ImportDocumentsParams,
   ImportResult,
+  UpdateDocumentStyleRequest,
 } from '../schemas'
 
 import { fetchApi } from '.././fetch'
@@ -406,6 +407,92 @@ export function useGetDocument<
   return { ...query, queryKey: queryOptions.queryKey }
 }
 
+export const getUpdateDocumentStyleUrl = (documentId: string) => {
+  return `/api/v1/documents/${documentId}/style`
+}
+
+export const updateDocumentStyle = async (
+  documentId: string,
+  updateDocumentStyleRequest: UpdateDocumentStyleRequest,
+  options?: RequestInit,
+): Promise<UpdateDocumentStyleRequest> => {
+  return fetchApi<UpdateDocumentStyleRequest>(
+    getUpdateDocumentStyleUrl(documentId),
+    {
+      ...options,
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json', ...options?.headers },
+      body: JSON.stringify(updateDocumentStyleRequest),
+    },
+  )
+}
+
+export const getUpdateDocumentStyleMutationOptions = <
+  TError = ApiError,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof updateDocumentStyle>>,
+    TError,
+    { documentId: string; data: UpdateDocumentStyleRequest },
+    TContext
+  >
+  request?: SecondParameter<typeof fetchApi>
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof updateDocumentStyle>>,
+  TError,
+  { documentId: string; data: UpdateDocumentStyleRequest },
+  TContext
+> => {
+  const mutationKey = ['updateDocumentStyle']
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation &&
+      'mutationKey' in options.mutation &&
+      options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined }
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof updateDocumentStyle>>,
+    { documentId: string; data: UpdateDocumentStyleRequest }
+  > = (props) => {
+    const { documentId, data } = props ?? {}
+
+    return updateDocumentStyle(documentId, data, requestOptions)
+  }
+
+  return { mutationFn, ...mutationOptions }
+}
+
+export type UpdateDocumentStyleMutationResult = NonNullable<
+  Awaited<ReturnType<typeof updateDocumentStyle>>
+>
+export type UpdateDocumentStyleMutationBody = UpdateDocumentStyleRequest
+export type UpdateDocumentStyleMutationError = ApiError
+
+export const useUpdateDocumentStyle = <TError = ApiError, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof updateDocumentStyle>>,
+      TError,
+      { documentId: string; data: UpdateDocumentStyleRequest },
+      TContext
+    >
+    request?: SecondParameter<typeof fetchApi>
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<ReturnType<typeof updateDocumentStyle>>,
+  TError,
+  { documentId: string; data: UpdateDocumentStyleRequest },
+  TContext
+> => {
+  return useMutation(
+    getUpdateDocumentStyleMutationOptions(options),
+    queryClient,
+  )
+}
 export const getGetDocumentThumbnailUrl = (
   documentId: string,
   params?: GetDocumentThumbnailParams,

ui/lib/api/schemas/documentDetail.ts

@@ -3,6 +3,7 @@
  * Do not edit manually.
  * OpenAPI spec version: 0.0.1
  */
+import type { DocumentStyle } from './documentStyle'
 import type { TextBlockDetail } from './textBlockDetail'
 
 export interface DocumentDetail {
@@ -32,6 +33,7 @@ export interface DocumentDetail {
    * @nullable
    */
   segment?: string | null
+  style?: null | DocumentStyle
   textBlocks: TextBlockDetail[]
   /** @minimum 0 */
   width: number

ui/lib/api/schemas/documentStyle.ts

@@ -0,0 +1,10 @@
+/**
+ * Generated by orval v8.6.2 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+
+export interface DocumentStyle {
+  /** @nullable */
+  defaultFont?: string | null
+}

ui/lib/api/schemas/fontFaceInfo.ts

@@ -3,8 +3,13 @@
  * Do not edit manually.
  * OpenAPI spec version: 0.0.1
  */
+import type { FontSource } from './fontSource'
 
 export interface FontFaceInfo {
+  cached: boolean
+  /** @nullable */
+  category?: string | null
   familyName: string
   postScriptName: string
+  source: FontSource
 }

ui/lib/api/schemas/fontSource.ts

@@ -0,0 +1,12 @@
+/**
+ * Generated by orval v8.6.2 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+
+export type FontSource = (typeof FontSource)[keyof typeof FontSource]
+
+export const FontSource = {
+  system: 'system',
+  google: 'google',
+} as const

ui/lib/api/schemas/googleFontCatalogEntry.ts

@@ -0,0 +1,12 @@
+/**
+ * Generated by orval v8.6.2 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+
+export interface GoogleFontCatalogEntry {
+  cached: boolean
+  category: string
+  family: string
+  subsets: string[]
+}

ui/lib/api/schemas/googleFontCatalogResponse.ts

@@ -0,0 +1,11 @@
+/**
+ * Generated by orval v8.6.2 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { GoogleFontCatalogEntry } from './googleFontCatalogEntry'
+
+export interface GoogleFontCatalogResponse {
+  fonts: GoogleFontCatalogEntry[]
+  recommended: string[]
+}

ui/lib/api/schemas/index.ts

@@ -9,6 +9,7 @@ export * from './brushRegionRequest'
 export * from './createTextBlock'
 export * from './dataConfig'
 export * from './documentDetail'
+export * from './documentStyle'
 export * from './documentSummary'
 export * from './downloadState'
 export * from './engineCatalogEntry'
@@ -18,10 +19,13 @@ export * from './exportLayer'
 export * from './exportResult'
 export * from './fontFaceInfo'
 export * from './fontPrediction'
+export * from './fontSource'
 export * from './getConfig200'
 export * from './getDocumentThumbnailParams'
 export * from './getEngineCatalog200'
 export * from './getLlmCatalogParams'
+export * from './googleFontCatalogEntry'
+export * from './googleFontCatalogResponse'
 export * from './httpConfig'
 export * from './importDocumentsBody'
 export * from './importDocumentsParams'
@@ -62,3 +66,4 @@ export * from './transferStatus'
 export * from './translateRequest'
 export * from './updateConfig200'
 export * from './updateConfigBody'
+export * from './updateDocumentStyleRequest'

ui/lib/api/schemas/pipelineJobRequest.ts

@@ -11,8 +11,6 @@ export interface PipelineJobRequest {
   /** @nullable */
   documentId?: string | null
   /** @nullable */
-  fontFamily?: string | null
-  /** @nullable */
   language?: string | null
   llm?: null | PipelineLlmRequest
   shaderEffect?: null | TextShaderEffect

ui/lib/api/schemas/renderRequest.ts

@@ -7,8 +7,6 @@ import type { TextShaderEffect } from './textShaderEffect'
 import type { TextStrokeStyle } from './textStrokeStyle'
 
 export interface RenderRequest {
-  /** @nullable */
-  fontFamily?: string | null
   shaderEffect?: null | TextShaderEffect
   shaderStroke?: null | TextStrokeStyle
   /** @nullable */

ui/lib/api/schemas/updateDocumentStyleRequest.ts

@@ -0,0 +1,10 @@
+/**
+ * Generated by orval v8.6.2 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+
+export interface UpdateDocumentStyleRequest {
+  /** @nullable */
+  defaultFont?: string | null
+}

ui/lib/api/system/system.ts

@@ -24,6 +24,7 @@ import type {
   FontFaceInfo,
   GetConfig200,
   GetEngineCatalog200,
+  GoogleFontCatalogResponse,
   MetaInfo,
   UpdateConfig200,
   UpdateConfigBody,
@@ -529,6 +530,403 @@ export function useListFonts<
   return { ...query, queryKey: queryOptions.queryKey }
 }
 
+export const getGetGoogleFontsCatalogUrl = () => {
+  return `/api/v1/fonts/google/catalog`
+}
+
+export const getGoogleFontsCatalog = async (
+  options?: RequestInit,
+): Promise<GoogleFontCatalogResponse> => {
+  return fetchApi<GoogleFontCatalogResponse>(getGetGoogleFontsCatalogUrl(), {
+    ...options,
+    method: 'GET',
+  })
+}
+
+export const getGetGoogleFontsCatalogQueryKey = () => {
+  return [`/api/v1/fonts/google/catalog`] as const
+}
+
+export const getGetGoogleFontsCatalogQueryOptions = <
+  TData = Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+  TError = ApiError,
+>(options?: {
+  query?: Partial<
+    UseQueryOptions<
+      Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+      TError,
+      TData
+    >
+  >
+  request?: SecondParameter<typeof fetchApi>
+}) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {}
+
+  const queryKey = queryOptions?.queryKey ?? getGetGoogleFontsCatalogQueryKey()
+
+  const queryFn: QueryFunction<
+    Awaited<ReturnType<typeof getGoogleFontsCatalog>>
+  > = ({ signal }) => getGoogleFontsCatalog({ signal, ...requestOptions })
+
+  return {
+    queryKey,
+    queryFn,
+    gcTime: 300000,
+    retry: 1,
+    ...queryOptions,
+  } as UseQueryOptions<
+    Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> }
+}
+
+export type GetGoogleFontsCatalogQueryResult = NonNullable<
+  Awaited<ReturnType<typeof getGoogleFontsCatalog>>
+>
+export type GetGoogleFontsCatalogQueryError = ApiError
+
+export function useGetGoogleFontsCatalog<
+  TData = Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+  TError = ApiError,
+>(
+  options: {
+    query: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        DefinedInitialDataOptions<
+          Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+          TError,
+          Awaited<ReturnType<typeof getGoogleFontsCatalog>>
+        >,
+        'initialData'
+      >
+    request?: SecondParameter<typeof fetchApi>
+  },
+  queryClient?: QueryClient,
+): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>
+}
+export function useGetGoogleFontsCatalog<
+  TData = Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+  TError = ApiError,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        UndefinedInitialDataOptions<
+          Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+          TError,
+          Awaited<ReturnType<typeof getGoogleFontsCatalog>>
+        >,
+        'initialData'
+      >
+    request?: SecondParameter<typeof fetchApi>
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>
+}
+export function useGetGoogleFontsCatalog<
+  TData = Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+  TError = ApiError,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+        TError,
+        TData
+      >
+    >
+    request?: SecondParameter<typeof fetchApi>
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>
+}
+
+export function useGetGoogleFontsCatalog<
+  TData = Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+  TError = ApiError,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof getGoogleFontsCatalog>>,
+        TError,
+        TData
+      >
+    >
+    request?: SecondParameter<typeof fetchApi>
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>
+} {
+  const queryOptions = getGetGoogleFontsCatalogQueryOptions(options)
+
+  const query = useQuery(queryOptions, queryClient) as UseQueryResult<
+    TData,
+    TError
+  > & { queryKey: DataTag<QueryKey, TData, TError> }
+
+  return { ...query, queryKey: queryOptions.queryKey }
+}
+
+export const getFetchGoogleFontUrl = (family: string) => {
+  return `/api/v1/fonts/google/${family}/fetch`
+}
+
+export const fetchGoogleFont = async (
+  family: string,
+  options?: RequestInit,
+): Promise<FontFaceInfo> => {
+  return fetchApi<FontFaceInfo>(getFetchGoogleFontUrl(family), {
+    ...options,
+    method: 'POST',
+  })
+}
+
+export const getFetchGoogleFontMutationOptions = <
+  TError = ApiError,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof fetchGoogleFont>>,
+    TError,
+    { family: string },
+    TContext
+  >
+  request?: SecondParameter<typeof fetchApi>
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof fetchGoogleFont>>,
+  TError,
+  { family: string },
+  TContext
+> => {
+  const mutationKey = ['fetchGoogleFont']
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation &&
+      'mutationKey' in options.mutation &&
+      options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined }
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof fetchGoogleFont>>,
+    { family: string }
+  > = (props) => {
+    const { family } = props ?? {}
+
+    return fetchGoogleFont(family, requestOptions)
+  }
+
+  return { mutationFn, ...mutationOptions }
+}
+
+export type FetchGoogleFontMutationResult = NonNullable<
+  Awaited<ReturnType<typeof fetchGoogleFont>>
+>
+
+export type FetchGoogleFontMutationError = ApiError
+
+export const useFetchGoogleFont = <TError = ApiError, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof fetchGoogleFont>>,
+      TError,
+      { family: string },
+      TContext
+    >
+    request?: SecondParameter<typeof fetchApi>
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<ReturnType<typeof fetchGoogleFont>>,
+  TError,
+  { family: string },
+  TContext
+> => {
+  return useMutation(getFetchGoogleFontMutationOptions(options), queryClient)
+}
+export const getGetGoogleFontFileUrl = (family: string) => {
+  return `/api/v1/fonts/google/${family}/file`
+}
+
+export const getGoogleFontFile = async (
+  family: string,
+  options?: RequestInit,
+): Promise<Blob> => {
+  return fetchApi<Blob>(getGetGoogleFontFileUrl(family), {
+    ...options,
+    method: 'GET',
+  })
+}
+
+export const getGetGoogleFontFileQueryKey = (family: string) => {
+  return [`/api/v1/fonts/google/${family}/file`] as const
+}
+
+export const getGetGoogleFontFileQueryOptions = <
+  TData = Awaited<ReturnType<typeof getGoogleFontFile>>,
+  TError = ApiError,
+>(
+  family: string,
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof getGoogleFontFile>>,
+        TError,
+        TData
+      >
+    >
+    request?: SecondParameter<typeof fetchApi>
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {}
+
+  const queryKey =
+    queryOptions?.queryKey ?? getGetGoogleFontFileQueryKey(family)
+
+  const queryFn: QueryFunction<
+    Awaited<ReturnType<typeof getGoogleFontFile>>
+  > = ({ signal }) => getGoogleFontFile(family, { signal, ...requestOptions })
+
+  return {
+    queryKey,
+    queryFn,
+    enabled: !!family,
+    gcTime: 300000,
+    retry: 1,
+    ...queryOptions,
+  } as UseQueryOptions<
+    Awaited<ReturnType<typeof getGoogleFontFile>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> }
+}
+
+export type GetGoogleFontFileQueryResult = NonNullable<
+  Awaited<ReturnType<typeof getGoogleFontFile>>
+>
+export type GetGoogleFontFileQueryError = ApiError
+
+export function useGetGoogleFontFile<
+  TData = Awaited<ReturnType<typeof getGoogleFontFile>>,
+  TError = ApiError,
+>(
+  family: string,
+  options: {
+    query: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof getGoogleFontFile>>,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        DefinedInitialDataOptions<
+          Awaited<ReturnType<typeof getGoogleFontFile>>,
+          TError,
+          Awaited<ReturnType<typeof getGoogleFontFile>>
+        >,
+        'initialData'
+      >
+    request?: SecondParameter<typeof fetchApi>
+  },
+  queryClient?: QueryClient,
+): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>
+}
+export function useGetGoogleFontFile<
+  TData = Awaited<ReturnType<typeof getGoogleFontFile>>,
+  TError = ApiError,
+>(
+  family: string,
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof getGoogleFontFile>>,
+        TError,
+        TData
+      >
+    > &
+      Pick<
+        UndefinedInitialDataOptions<
+          Awaited<ReturnType<typeof getGoogleFontFile>>,
+          TError,
+          Awaited<ReturnType<typeof getGoogleFontFile>>
+        >,
+        'initialData'
+      >
+    request?: SecondParameter<typeof fetchApi>
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>
+}
+export function useGetGoogleFontFile<
+  TData = Awaited<ReturnType<typeof getGoogleFontFile>>,
+  TError = ApiError,
+>(
+  family: string,
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof getGoogleFontFile>>,
+        TError,
+        TData
+      >
+    >
+    request?: SecondParameter<typeof fetchApi>
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>
+}
+
+export function useGetGoogleFontFile<
+  TData = Awaited<ReturnType<typeof getGoogleFontFile>>,
+  TError = ApiError,
+>(
+  family: string,
+  options?: {
+    query?: Partial<
+      UseQueryOptions<
+        Awaited<ReturnType<typeof getGoogleFontFile>>,
+        TError,
+        TData
+      >
+    >
+    request?: SecondParameter<typeof fetchApi>
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>
+} {
+  const queryOptions = getGetGoogleFontFileQueryOptions(family, options)
+
+  const query = useQuery(queryOptions, queryClient) as UseQueryResult<
+    TData,
+    TError
+  > & { queryKey: DataTag<QueryKey, TData, TError> }
+
+  return { ...query, queryKey: queryOptions.queryKey }
+}
+
 export const getGetMetaUrl = () => {
   return `/api/v1/meta`
 }

ui/lib/stores/preferencesStore.ts

@@ -9,8 +9,6 @@ type PreferencesState = {
     color: string
   }
   setBrushConfig: (config: Partial<PreferencesState['brushConfig']>) => void
-  fontFamily?: string
-  setFontFamily: (font?: string) => void
   resetPreferences: () => void
 }
 
@@ -19,7 +17,6 @@ const initialPreferences = {
     size: 36,
     color: '#ffffff',
   },
-  fontFamily: undefined as string | undefined,
 }
 
 export const usePreferencesStore = create<PreferencesState>()(
@@ -33,7 +30,6 @@ export const usePreferencesStore = create<PreferencesState>()(
             ...config,
           },
         })),
-      setFontFamily: (font) => set({ fontFamily: font }),
       resetPreferences: () => set({ ...initialPreferences }),
     }),
     {
@@ -53,7 +49,6 @@ export const usePreferencesStore = create<PreferencesState>()(
       },
       partialize: (state) => ({
         brushConfig: state.brushConfig,
-        fontFamily: state.fontFamily,
       }),
     },
   ),

ui/openapi.json

@@ -816,6 +816,65 @@
         }
       }
     },
+    "/documents/{document_id}/style": {
+      "patch": {
+        "tags": ["documents"],
+        "operationId": "updateDocumentStyle",
+        "parameters": [
+          {
+            "name": "document_id",
+            "in": "path",
+            "description": "Document ID",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdateDocumentStyleRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UpdateDocumentStyleRequest"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          },
+          "503": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/documents/{document_id}/text-blocks": {
       "put": {
         "tags": ["text-blocks"],
@@ -1316,6 +1375,128 @@
         }
       }
     },
+    "/fonts/google/catalog": {
+      "get": {
+        "tags": ["system"],
+        "operationId": "getGoogleFontsCatalog",
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/GoogleFontCatalogResponse"
+                }
+              }
+            }
+          },
+          "503": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/fonts/google/{family}/fetch": {
+      "post": {
+        "tags": ["system"],
+        "operationId": "fetchGoogleFont",
+        "parameters": [
+          {
+            "name": "family",
+            "in": "path",
+            "description": "Font family name",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/FontFaceInfo"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          },
+          "503": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/fonts/google/{family}/file": {
+      "get": {
+        "tags": ["system"],
+        "operationId": "getGoogleFontFile",
+        "parameters": [
+          {
+            "name": "family",
+            "in": "path",
+            "description": "Font family name",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Font file bytes",
+            "content": {
+              "font/ttf": {}
+            }
+          },
+          "404": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          },
+          "503": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/jobs": {
       "get": {
         "tags": ["jobs"],
@@ -1718,6 +1899,16 @@
             "type": ["string", "null"],
             "description": "Blob hash for the segmentation mask layer."
           },
+          "style": {
+            "oneOf": [
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/components/schemas/DocumentStyle"
+              }
+            ]
+          },
           "textBlocks": {
             "type": "array",
             "items": {
@@ -1731,6 +1922,14 @@
           }
         }
       },
+      "DocumentStyle": {
+        "type": "object",
+        "properties": {
+          "defaultFont": {
+            "type": ["string", "null"]
+          }
+        }
+      },
       "DocumentSummary": {
         "type": "object",
         "required": [
@@ -1856,13 +2055,22 @@
       },
       "FontFaceInfo": {
         "type": "object",
-        "required": ["familyName", "postScriptName"],
+        "required": ["familyName", "postScriptName", "source", "cached"],
         "properties": {
+          "cached": {
+            "type": "boolean"
+          },
+          "category": {
+            "type": ["string", "null"]
+          },
           "familyName": {
             "type": "string"
           },
           "postScriptName": {
             "type": "string"
+          },
+          "source": {
+            "$ref": "#/components/schemas/FontSource"
           }
         }
       },
@@ -1929,6 +2137,49 @@
           }
         }
       },
+      "FontSource": {
+        "type": "string",
+        "enum": ["system", "google"]
+      },
+      "GoogleFontCatalogEntry": {
+        "type": "object",
+        "required": ["family", "category", "subsets", "cached"],
+        "properties": {
+          "cached": {
+            "type": "boolean"
+          },
+          "category": {
+            "type": "string"
+          },
+          "family": {
+            "type": "string"
+          },
+          "subsets": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        }
+      },
+      "GoogleFontCatalogResponse": {
+        "type": "object",
+        "required": ["fonts", "recommended"],
+        "properties": {
+          "fonts": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/GoogleFontCatalogEntry"
+            }
+          },
+          "recommended": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        }
+      },
       "HttpConfig": {
         "type": "object",
         "properties": {
@@ -2304,9 +2555,6 @@
           "documentId": {
             "type": ["string", "null"]
           },
-          "fontFamily": {
-            "type": ["string", "null"]
-          },
           "language": {
             "type": ["string", "null"]
           },
@@ -2406,9 +2654,6 @@
       "RenderRequest": {
         "type": "object",
         "properties": {
-          "fontFamily": {
-            "type": ["string", "null"]
-          },
           "shaderEffect": {
             "oneOf": [
               {
@@ -2756,6 +3001,14 @@
             "type": ["string", "null"]
           }
         }
+      },
+      "UpdateDocumentStyleRequest": {
+        "type": "object",
+        "properties": {
+          "defaultFont": {
+            "type": ["string", "null"]
+          }
+        }
       }
     }
   }