refactor: split modules

Cargo.lock

@@ -423,15 +423,6 @@ dependencies = [
  "system-deps",
 ]
 
-[[package]]
-name = "atomic-polyfill"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"
-dependencies = [
- "critical-section",
-]
-
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -1067,15 +1058,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "cobs"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
-dependencies = [
- "thiserror 2.0.18",
-]
-
 [[package]]
 name = "codespan-reporting"
 version = "0.12.0"
@@ -1300,12 +1282,6 @@ dependencies = [
  "itertools 0.13.0",
 ]
 
-[[package]]
-name = "critical-section"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
-
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.15"
@@ -1770,18 +1746,6 @@ version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
 
-[[package]]
-name = "embedded-io"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
-
-[[package]]
-name = "embedded-io"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
-
 [[package]]
 name = "encode_unicode"
 version = "1.0.0"
@@ -1815,18 +1779,6 @@ dependencies = [
  "syn 2.0.114",
 ]
 
-[[package]]
-name = "enum_dispatch"
-version = "0.3.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"
-dependencies = [
- "once_cell",
- "proc-macro2",
- "quote",
- "syn 2.0.114",
-]
-
 [[package]]
 name = "enumflags2"
 version = "0.7.12"
@@ -3001,15 +2953,6 @@ dependencies = [
  "smallvec",
 ]
 
-[[package]]
-name = "hash32"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
-dependencies = [
- "byteorder",
-]
-
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -3040,20 +2983,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "heapless"
-version = "0.7.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
-dependencies = [
- "atomic-polyfill",
- "hash32",
- "rustc_version",
- "serde",
- "spin",
- "stable_deref_trait",
-]
-
 [[package]]
 name = "heck"
 version = "0.4.1"
@@ -4021,38 +3950,22 @@ name = "koharu"
 version = "0.32.8"
 dependencies = [
  "anyhow",
- "async-trait",
- "axum",
- "blake3",
  "clap",
  "dirs",
- "enum_dispatch",
- "futures",
  "git-version",
- "icu",
- "image",
- "koharu-core",
  "koharu-ml",
+ "koharu-pipeline",
  "koharu-renderer",
+ "koharu-rpc",
  "koharu-runtime",
+ "koharu-types",
  "once_cell",
- "open",
- "postcard",
- "rayon",
  "rfd",
- "rmp-serde",
- "rmpv",
- "serde",
- "serde_bytes",
  "serde_json",
- "strum",
- "sys-locale",
  "tauri",
  "tauri-build",
  "tauri-plugin-updater",
- "thiserror 2.0.18",
  "tokio",
- "tower",
  "tracing",
  "tracing-subscriber",
  "windows 0.62.2",
@@ -4061,7 +3974,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "koharu-core"
+name = "koharu-http"
 version = "0.32.8"
 dependencies = [
  "anyhow",
@@ -4092,7 +4005,8 @@ dependencies = [
  "futures",
  "image",
  "imageproc",
- "koharu-core",
+ "koharu-http",
+ "koharu-types",
  "libloading 0.9.0",
  "minijinja",
  "num_cpus",
@@ -4113,6 +4027,26 @@ dependencies = [
  "tracing-subscriber",
 ]
 
+[[package]]
+name = "koharu-pipeline"
+version = "0.32.8"
+dependencies = [
+ "anyhow",
+ "image",
+ "koharu-ml",
+ "koharu-renderer",
+ "koharu-types",
+ "once_cell",
+ "open",
+ "rayon",
+ "serde",
+ "serde_bytes",
+ "strum",
+ "sys-locale",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "koharu-renderer"
 version = "0.32.8"
@@ -4127,7 +4061,9 @@ dependencies = [
  "harfrust",
  "icu",
  "image",
+ "koharu-types",
  "once_cell",
+ "rayon",
  "serde",
  "skrifa",
  "tokio",
@@ -4135,6 +4071,22 @@ dependencies = [
  "wgpu",
 ]
 
+[[package]]
+name = "koharu-rpc"
+version = "0.32.8"
+dependencies = [
+ "anyhow",
+ "axum",
+ "futures",
+ "koharu-http",
+ "koharu-pipeline",
+ "rmp-serde",
+ "rmpv",
+ "serde",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "koharu-runtime"
 version = "0.32.8"
@@ -4143,7 +4095,7 @@ dependencies = [
  "csv",
  "flate2",
  "futures",
- "koharu-core",
+ "koharu-http",
  "libloading 0.9.0",
  "num_cpus",
  "once_cell",
@@ -4156,6 +4108,19 @@ dependencies = [
  "zip 7.4.0",
 ]
 
+[[package]]
+name = "koharu-types"
+version = "0.32.8"
+dependencies = [
+ "anyhow",
+ "blake3",
+ "image",
+ "serde",
+ "serde_bytes",
+ "sys-locale",
+ "tokio",
+]
+
 [[package]]
 name = "kuchikiki"
 version = "0.8.8-speedreader"
@@ -5630,19 +5595,6 @@ dependencies = [
  "portable-atomic",
 ]
 
-[[package]]
-name = "postcard"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
-dependencies = [
- "cobs",
- "embedded-io 0.4.0",
- "embedded-io 0.6.1",
- "heapless",
- "serde",
-]
-
 [[package]]
 name = "potential_utf"
 version = "0.1.4"
@@ -7128,15 +7080,6 @@ dependencies = [
  "system-deps",
 ]
 
-[[package]]
-name = "spin"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
-dependencies = [
- "lock_api",
-]
-
 [[package]]
 name = "spirv"
 version = "0.3.0+sdk-1.3.268.0"

Cargo.toml

@@ -1,10 +1,13 @@
 [workspace]
 members = [
     "koharu",
-    "koharu-core",
+    "koharu-http",
     "koharu-ml",
     "koharu-runtime",
     "koharu-renderer",
+    "koharu-pipeline",
+    "koharu-rpc",
+    "koharu-types",
 ]
 default-members = ["koharu"]
 resolver = "3"
@@ -25,10 +28,13 @@ keywords = ["manga", "ocr", "translation", "deep_learning", "computer_vision"]
 publish = false
 
 [workspace.dependencies]
-koharu-core = { path = "koharu-core", default-features = false }
+koharu-http = { path = "koharu-http", default-features = false }
 koharu-runtime = { path = "koharu-runtime", default-features = false }
 koharu-ml = { path = "koharu-ml", default-features = false }
 koharu-renderer = { path = "koharu-renderer", default-features = false }
+koharu-pipeline = { path = "koharu-pipeline", default-features = false }
+koharu-rpc = { path = "koharu-rpc", default-features = false }
+koharu-types = { path = "koharu-types", default-features = false }
 candle-transformers = "=0.9.2"
 candle-core = "=0.9.2"
 candle-nn = "=0.9.2"

{koharu-core → koharu-http}/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "koharu-core"
+name = "koharu-http"
 version.workspace = true
 edition.workspace = true
 description.workspace = true

koharu-ml/Cargo.toml

@@ -12,7 +12,8 @@ keywords.workspace = true
 publish.workspace = true
 
 [dependencies]
-koharu-core = { workspace = true }
+koharu-http = { workspace = true }
+koharu-types = { workspace = true }
 anyhow = { workspace = true }
 clap = { workspace = true }
 image = { workspace = true }

koharu/src/ml.rs → koharu-ml/src/facade.rs

@@ -1,12 +1,11 @@
 use anyhow::Result;
 use image::{DynamicImage, Rgba};
-use koharu_ml::comic_text_detector::{self, ComicTextDetector};
-use koharu_ml::font_detector::{self, FontDetector};
-use koharu_ml::lama::{self, Lama};
-use koharu_ml::manga_ocr::{self, MangaOcr};
+use koharu_types::{Document, FontPrediction, SerializableDynamicImage, TextBlock, TextStyle};
 
-use crate::image::SerializableDynamicImage;
-use crate::state::{Document, TextBlock, TextStyle};
+use crate::comic_text_detector::{self, ComicTextDetector};
+use crate::font_detector::{self, FontDetector};
+use crate::lama::{self, Lama};
+use crate::manga_ocr::{self, MangaOcr};
 
 const NEAR_BLACK_THRESHOLD: u8 = 12;
 const GRAY_NEAR_BLACK_THRESHOLD: u8 = 60;
@@ -56,7 +55,7 @@ fn colors_similar(a: [u8; 3], b: [u8; 3]) -> bool {
         && a[2].abs_diff(b[2]) <= SIMILAR_COLOR_MAX_DIFF
 }
 
-fn normalize_font_prediction(prediction: &mut font_detector::FontPrediction) {
+fn normalize_font_prediction(prediction: &mut FontPrediction) {
     prediction.text_color = clamp_near_white(clamp_near_black(prediction.text_color));
     prediction.stroke_color = clamp_near_white(clamp_near_black(prediction.stroke_color));
 
@@ -213,11 +212,7 @@ impl Model {
         Ok(result.into())
     }
 
-    pub async fn detect_font(
-        &self,
-        image: &DynamicImage,
-        top_k: usize,
-    ) -> Result<font_detector::FontPrediction> {
+    pub async fn detect_font(&self, image: &DynamicImage, top_k: usize) -> Result<FontPrediction> {
         let mut results = self
             .detect_fonts(std::slice::from_ref(image), top_k)
             .await?;
@@ -228,7 +223,7 @@ impl Model {
         &self,
         images: &[DynamicImage],
         top_k: usize,
-    ) -> Result<Vec<font_detector::FontPrediction>> {
+    ) -> Result<Vec<FontPrediction>> {
         if images.is_empty() {
             return Ok(Vec::new());
         }

koharu-ml/src/font_detector/mod.rs

@@ -1,5 +1,6 @@
 use std::{fs, path::PathBuf};
 
+use crate::{define_models, device};
 use anyhow::{Context, Result};
 use candle_core::{DType, Device, IndexOp, Tensor};
 use candle_nn::{
@@ -7,9 +8,6 @@ use candle_nn::{
     ops::{sigmoid, softmax},
 };
 use image::{DynamicImage, GenericImageView, imageops::FilterType};
-use serde::{Deserialize, Serialize};
-
-use crate::{define_models, device};
 
 mod models;
 pub use models::ModelKind;
@@ -23,50 +21,7 @@ define_models! {
     FontNames => ("fffonion/yuzumarker-font-detection", "font-labels-ex.json"),
 }
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
-pub enum TextDirection {
-    Horizontal,
-    Vertical,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct NamedFontPrediction {
-    pub index: usize,
-    pub name: String,
-    pub language: Option<String>,
-    pub probability: f32,
-    pub serif: bool,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct FontPrediction {
-    pub top_fonts: Vec<(usize, f32)>,
-    pub named_fonts: Vec<NamedFontPrediction>,
-    pub direction: TextDirection,
-    pub text_color: [u8; 3],
-    pub stroke_color: [u8; 3],
-    pub font_size_px: f32,
-    pub stroke_width_px: f32,
-    pub line_height: f32,
-    pub angle_deg: f32,
-}
-
-// implement Default for FontPrediction
-impl Default for FontPrediction {
-    fn default() -> Self {
-        Self {
-            top_fonts: Vec::new(),
-            named_fonts: Vec::new(),
-            direction: TextDirection::Horizontal,
-            text_color: [0, 0, 0],
-            stroke_color: [0, 0, 0],
-            font_size_px: 0.0,
-            stroke_width_px: 0.0,
-            line_height: 1.0,
-            angle_deg: 0.0,
-        }
-    }
-}
+pub use koharu_types::{FontPrediction, NamedFontPrediction, TextDirection};
 
 pub struct FontDetector {
     model: models::Model,

koharu-ml/src/hf_hub.rs

@@ -1,7 +1,7 @@
 #[allow(unused_imports)]
-pub use koharu_core::download::model;
+pub use koharu_http::download::model;
 #[allow(unused_imports)]
-pub use koharu_core::hf_hub::set_cache_dir;
+pub use koharu_http::hf_hub::set_cache_dir;
 
 #[macro_export]
 macro_rules! define_models {
@@ -19,7 +19,7 @@ macro_rules! define_models {
                 use strum::EnumProperty;
                 let repo = self.get_str("repo").expect("repo property");
                 let filename = self.get_str("filename").expect("filename property");
-                koharu_core::download::model(repo, filename).await
+                koharu_http::download::model(repo, filename).await
             }
         }
 

koharu-ml/src/lib.rs

@@ -1,6 +1,7 @@
 mod hf_hub;
 
 pub mod comic_text_detector;
+pub mod facade;
 pub mod font_detector;
 pub mod lama;
 pub mod llm;
@@ -9,7 +10,7 @@ pub mod manga_ocr;
 use anyhow::Result;
 use candle_core::{Device, utils::metal_is_available};
 
-pub use koharu_core::hf_hub::set_cache_dir;
+pub use koharu_http::hf_hub::set_cache_dir;
 pub use llm::{language_from_tag, set_default_locale, set_locale, supported_locales};
 
 /// Name of the compute device being used.

koharu/src/llm.rs → koharu-ml/src/llm/facade.rs

@@ -1,12 +1,14 @@
-use koharu_ml::llm::{GenerateOptions, Llm, ModelId};
-use serde::Serialize;
 use std::sync::Arc;
+
+use serde::Serialize;
 use strum::Display;
 use tokio::sync::RwLock;
 
-use crate::state::{Document, TextBlock};
+use koharu_types::{Document, TextBlock};
+
+use super::{GenerateOptions, Llm, ModelId};
 
-pub use koharu_ml::llm::prefetch;
+pub use super::prefetch;
 
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -128,13 +130,11 @@ impl Model {
     }
 
     /// Returns a read guard to the internal state.
-    /// Callers can inspect `State` directly while holding the guard.
     pub async fn get(&self) -> tokio::sync::RwLockReadGuard<'_, State> {
         self.state.read().await
     }
 
     /// Returns a write guard to the internal state.
-    /// Needed for operations that mutate the loaded LLM instance.
     pub async fn get_mut(&self) -> tokio::sync::RwLockWriteGuard<'_, State> {
         self.state.write().await
     }

koharu-ml/src/llm/mod.rs

@@ -1,3 +1,4 @@
+pub mod facade;
 mod model;
 pub mod prompt;
 mod quantized_hunyuan_dense;

koharu-pipeline/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "koharu-pipeline"
+version.workspace = true
+edition.workspace = true
+description.workspace = true
+authors.workspace = true
+publish.workspace = true
+
+[dependencies]
+koharu-types = { workspace = true }
+koharu-ml = { workspace = true }
+koharu-renderer = { workspace = true }
+anyhow = { workspace = true }
+image = { workspace = true }
+once_cell = { workspace = true }
+open = { workspace = true }
+rayon = { workspace = true }
+serde = { workspace = true }
+serde_bytes = { workspace = true }
+strum = { workspace = true }
+sys-locale = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }

koharu-pipeline/src/lib.rs

@@ -0,0 +1,20 @@
+pub mod operations;
+pub mod pipeline;
+
+use std::sync::Arc;
+
+use koharu_ml::DeviceName;
+use koharu_renderer::facade::Renderer;
+use koharu_types::AppState;
+use tokio::sync::RwLock;
+
+#[derive(Clone)]
+pub struct AppResources {
+    pub state: AppState,
+    pub ml: Arc<koharu_ml::facade::Model>,
+    pub llm: Arc<koharu_ml::llm::facade::Model>,
+    pub renderer: Arc<Renderer>,
+    pub ml_device: DeviceName,
+    pub pipeline: Arc<RwLock<Option<pipeline::PipelineHandle>>>,
+    pub version: &'static str,
+}

{koharu → koharu-pipeline}/src/operations.rs

@@ -9,17 +9,14 @@ use strum::IntoEnumIterator;
 use sys_locale::get_locale;
 use tracing::instrument;
 
-use crate::{
-    app::AppResources,
-    image::SerializableDynamicImage,
-    khr::{deserialize_khr, has_khr_magic, serialize_khr},
-    llm,
-    state::{Document, TextBlock},
-    version,
-};
+use koharu_types::{Document, SerializableDynamicImage, TextBlock};
 
-pub async fn app_version(_state: AppResources) -> anyhow::Result<String> {
-    Ok(version::current().to_string())
+use koharu_ml::llm::facade as llm;
+
+use crate::AppResources;
+
+pub async fn app_version(state: AppResources) -> anyhow::Result<String> {
+    Ok(state.version.to_string())
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -42,7 +39,10 @@ pub struct OpenExternalPayload {
     pub url: String,
 }
 
-pub fn open_external(payload: OpenExternalPayload) -> anyhow::Result<()> {
+pub async fn open_external(
+    _state: AppResources,
+    payload: OpenExternalPayload,
+) -> anyhow::Result<()> {
     open::that(&payload.url)?;
     Ok(())
 }
@@ -142,33 +142,6 @@ pub struct FileResult {
     pub content_type: String,
 }
 
-pub async fn save_documents(state: AppResources) -> anyhow::Result<FileResult> {
-    let guard = state.state.read().await;
-    if guard.documents.is_empty() {
-        anyhow::bail!("No documents to save");
-    }
-
-    let filename = if guard.documents.len() == 1 {
-        let stem = guard.documents[0]
-            .path
-            .file_stem()
-            .and_then(|s| s.to_str())
-            .unwrap_or("project");
-        format!("{}.khr", stem)
-    } else {
-        "project.khr".to_string()
-    };
-
-    let bytes = serialize_khr(&guard.documents)?;
-    drop(guard);
-
-    Ok(FileResult {
-        filename,
-        data: bytes,
-        content_type: "application/octet-stream".to_string(),
-    })
-}
-
 pub async fn export_document(
     state: AppResources,
     payload: IndexPayload,
@@ -766,13 +739,6 @@ pub fn load_documents(inputs: Vec<(PathBuf, Vec<u8>)>) -> anyhow::Result<Vec<Doc
         return Ok(vec![]);
     }
 
-    if inputs.len() == 1 {
-        let (_, ref bytes) = inputs[0];
-        if has_khr_magic(bytes) {
-            return deserialize_khr(bytes);
-        }
-    }
-
     let mut documents: Vec<_> = inputs
         .into_par_iter()
         .filter_map(|(path, bytes)| match Document::from_bytes(path, bytes) {

{koharu → koharu-pipeline}/src/pipeline.rs

@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 use tokio::sync::broadcast;
 
-use crate::app::AppResources;
+use crate::AppResources;
 
 /// Steps in the processing pipeline.
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]

koharu-renderer/Cargo.toml

@@ -12,6 +12,7 @@ keywords.workspace = true
 publish.workspace = true
 
 [dependencies]
+koharu-types = { workspace = true }
 anyhow = { workspace = true }
 image = { workspace = true }
 once_cell = { workspace = true }
@@ -26,6 +27,7 @@ wgpu = { workspace = true }
 etagere = { workspace = true }
 bytemuck = { workspace = true }
 tracing = { workspace = true }
+rayon = { workspace = true }
 
 [dev-dependencies]
 tokio = { workspace = true }

koharu/src/renderer.rs → koharu-renderer/src/facade.rs

@@ -3,16 +3,14 @@ use std::sync::{Arc, Mutex};
 use anyhow::Result;
 use icu::properties::{CodePointMapData, props::Script};
 use image::{DynamicImage, imageops};
-use koharu_renderer::{
-    font::{FamilyName, Font, FontBook, Properties},
-    layout::{LayoutRun, TextLayout, WritingMode},
-    renderer::{RenderOptions, TextShaderEffect, WgpuDeviceInfo, WgpuRenderer},
-};
 use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
 
+use koharu_types::{Document, SerializableDynamicImage, TextBlock, TextShaderEffect, TextStyle};
+
 use crate::{
-    image::SerializableDynamicImage,
-    state::{Document, TextBlock, TextStyle},
+    font::{FamilyName, Font, FontBook, Properties},
+    layout::{LayoutRun, TextLayout, WritingMode},
+    renderer::{RenderOptions, WgpuDeviceInfo, WgpuRenderer},
 };
 
 pub struct Renderer {

koharu-renderer/src/lib.rs

@@ -1,3 +1,4 @@
+pub mod facade;
 pub mod font;
 pub mod layout;
 pub mod renderer;

koharu-renderer/src/renderer.rs

@@ -11,29 +11,7 @@ use wgpu::util::DeviceExt;
 use crate::font::Font;
 use crate::layout::{LayoutRun, PositionedGlyph, WritingMode};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-#[derive(Default)]
-pub enum TextShaderEffect {
-    #[default]
-    Normal,
-    Antique,
-    Metal,
-    Manga,
-    MotionBlur,
-}
-
-impl TextShaderEffect {
-    fn id(self) -> f32 {
-        match self {
-            Self::Normal => 0.0,
-            Self::Antique => 1.0,
-            Self::Metal => 2.0,
-            Self::Manga => 3.0,
-            Self::MotionBlur => 4.0,
-        }
-    }
-}
+pub use koharu_types::TextShaderEffect;
 
 /// Options for rendering text.
 #[derive(Debug, Clone)]

koharu-rpc/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "koharu-rpc"
+version.workspace = true
+edition.workspace = true
+description.workspace = true
+authors.workspace = true
+publish.workspace = true
+
+[dependencies]
+koharu-http = { workspace = true }
+koharu-pipeline = { workspace = true }
+anyhow = { workspace = true }
+axum = { workspace = true }
+futures = { workspace = true }
+rmp-serde = { workspace = true }
+rmpv = { workspace = true }
+serde = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }

koharu-rpc/src/lib.rs

@@ -0,0 +1,4 @@
+pub mod rpc;
+pub mod server;
+
+pub use rpc::{SharedResources, WsState};

koharu-rpc/src/rpc.rs

@@ -0,0 +1,226 @@
+use std::future::Future;
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::Result;
+use axum::{
+    extract::{
+        State,
+        ws::{Message, WebSocket, WebSocketUpgrade},
+    },
+    response::IntoResponse,
+};
+use futures::{SinkExt, StreamExt};
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
+use tokio::sync::{broadcast, mpsc};
+
+use koharu_pipeline::AppResources;
+use koharu_pipeline::operations;
+
+pub type SharedResources = Arc<tokio::sync::OnceCell<AppResources>>;
+
+#[derive(Debug, Deserialize)]
+struct RawIncoming {
+    id: u32,
+    method: String,
+    params: Option<rmpv::Value>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+pub enum OutgoingMessage {
+    #[serde(rename = "res")]
+    Response {
+        id: u32,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        result: Option<rmpv::Value>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        error: Option<String>,
+    },
+    #[serde(rename = "ntf")]
+    Notification { method: String, params: rmpv::Value },
+}
+
+fn ok_response(id: u32, result: rmpv::Value) -> OutgoingMessage {
+    OutgoingMessage::Response {
+        id,
+        result: Some(result),
+        error: None,
+    }
+}
+
+fn err_response(id: u32, msg: &str) -> OutgoingMessage {
+    OutgoingMessage::Response {
+        id,
+        result: None,
+        error: Some(msg.to_string()),
+    }
+}
+
+fn to_value<T: Serialize>(val: &T) -> Result<rmpv::Value> {
+    let bytes = rmp_serde::to_vec_named(val)?;
+    Ok(rmp_serde::from_slice(&bytes)?)
+}
+
+fn from_value<T: DeserializeOwned>(val: rmpv::Value) -> Result<T> {
+    let bytes = rmp_serde::to_vec_named(&val)?;
+    Ok(rmp_serde::from_slice(&bytes)?)
+}
+
+async fn call<F, Fut, P, T>(f: F, state: AppResources, params: rmpv::Value) -> Result<rmpv::Value>
+where
+    F: FnOnce(AppResources, P) -> Fut,
+    Fut: Future<Output = Result<T>>,
+    P: DeserializeOwned,
+    T: Serialize,
+{
+    to_value(&f(state, from_value(params)?).await?)
+}
+
+async fn call0<F, Fut, T>(f: F, state: AppResources) -> Result<rmpv::Value>
+where
+    F: FnOnce(AppResources) -> Fut,
+    Fut: Future<Output = Result<T>>,
+    T: Serialize,
+{
+    to_value(&f(state).await?)
+}
+
+async fn dispatch(method: &str, params: rmpv::Value, state: AppResources) -> Result<rmpv::Value> {
+    match method {
+        "app_version" => call0(operations::app_version, state).await,
+        "device" => call0(operations::device, state).await,
+        "get_documents" => call0(operations::get_documents, state).await,
+        "list_font_families" => call0(operations::list_font_families, state).await,
+        "llm_list" => call0(operations::llm_list, state).await,
+        "llm_ready" => call0(operations::llm_ready, state).await,
+        "llm_offload" => call0(operations::llm_offload, state).await,
+        "process_cancel" => call0(operations::process_cancel, state).await,
+        "get_document" => call(operations::get_document, state, params).await,
+        "get_thumbnail" => call(operations::get_thumbnail, state, params).await,
+        "export_document" => call(operations::export_document, state, params).await,
+        "open_documents" => call(operations::open_documents, state, params).await,
+        "open_external" => call(operations::open_external, state, params).await,
+        "detect" => call(operations::detect, state, params).await,
+        "ocr" => call(operations::ocr, state, params).await,
+        "inpaint" => call(operations::inpaint, state, params).await,
+        "update_inpaint_mask" => call(operations::update_inpaint_mask, state, params).await,
+        "update_brush_layer" => call(operations::update_brush_layer, state, params).await,
+        "inpaint_partial" => call(operations::inpaint_partial, state, params).await,
+        "render" => call(operations::render, state, params).await,
+        "update_text_blocks" => call(operations::update_text_blocks, state, params).await,
+        "llm_load" => call(operations::llm_load, state, params).await,
+        "llm_generate" => call(operations::llm_generate, state, params).await,
+        "process" => call(operations::process, state, params).await,
+        _ => Err(anyhow::anyhow!("Unknown method: {}", method)),
+    }
+}
+
+#[derive(Clone)]
+pub struct WsState {
+    pub resources: SharedResources,
+}
+
+pub async fn ws_handler(ws: WebSocketUpgrade, State(state): State<WsState>) -> impl IntoResponse {
+    ws.max_message_size(1024 * 1024 * 1024)
+        .on_upgrade(|socket| handle_socket(socket, state))
+}
+
+async fn handle_socket(socket: WebSocket, state: WsState) {
+    let (mut ws_sender, mut ws_receiver) = socket.split();
+    let (tx, mut send_rx) = mpsc::channel::<OutgoingMessage>(256);
+
+    // Notification forwarders
+    spawn_notification_forwarder(
+        "download_progress",
+        koharu_http::download::subscribe(),
+        tx.clone(),
+    );
+    spawn_notification_forwarder(
+        "process_progress",
+        koharu_pipeline::pipeline::subscribe(),
+        tx.clone(),
+    );
+
+    // Sender task: drain mpsc → WebSocket binary frames
+    let send_task = tokio::spawn(async move {
+        while let Some(msg) = send_rx.recv().await {
+            let Ok(bytes) = rmp_serde::to_vec_named(&msg) else {
+                continue;
+            };
+            if ws_sender.send(Message::Binary(bytes.into())).await.is_err() {
+                break;
+            }
+        }
+    });
+
+    // Receive loop
+    while let Some(Ok(msg)) = ws_receiver.next().await {
+        let data = match msg {
+            Message::Binary(data) => data,
+            Message::Close(_) => break,
+            _ => continue,
+        };
+
+        let raw: RawIncoming = match rmp_serde::from_slice(&data) {
+            Ok(r) => r,
+            Err(e) => {
+                let _ = tx
+                    .send(err_response(0, &format!("Decode error: {e}")))
+                    .await;
+                continue;
+            }
+        };
+
+        let id = raw.id;
+        let tx = tx.clone();
+        let resources = state.resources.clone();
+
+        tokio::spawn(async move {
+            let response = match resources.get() {
+                Some(res) => {
+                    let params = raw.params.unwrap_or(rmpv::Value::Nil);
+                    match tokio::time::timeout(
+                        Duration::from_secs(300),
+                        dispatch(&raw.method, params, res.clone()),
+                    )
+                    .await
+                    {
+                        Ok(Ok(result)) => ok_response(id, result),
+                        Ok(Err(e)) => err_response(id, &format!("{e:#}")),
+                        Err(_) => err_response(id, "Request timed out"),
+                    }
+                }
+                None => err_response(id, "Resources not initialized"),
+            };
+            let _ = tx.send(response).await;
+        });
+    }
+
+    send_task.abort();
+}
+
+fn spawn_notification_forwarder<T: Serialize + Clone + Send + 'static>(
+    method: &'static str,
+    mut rx: broadcast::Receiver<T>,
+    tx: mpsc::Sender<OutgoingMessage>,
+) {
+    tokio::spawn(async move {
+        loop {
+            match rx.recv().await {
+                Ok(payload) => {
+                    let params = to_value(&payload).unwrap_or(rmpv::Value::Nil);
+                    let msg = OutgoingMessage::Notification {
+                        method: method.to_string(),
+                        params,
+                    };
+                    if tx.send(msg).await.is_err() {
+                        break;
+                    }
+                }
+                Err(broadcast::error::RecvError::Lagged(_)) => continue,
+                Err(broadcast::error::RecvError::Closed) => break,
+            }
+        }
+    });
+}

{koharu → koharu-rpc}/src/server.rs

@@ -8,12 +8,20 @@ use axum::{
     response::{IntoResponse, Response},
     routing::get,
 };
-use tauri::AssetResolver;
 use tokio::net::TcpListener;
 
 use crate::rpc::{self, SharedResources, WsState};
 
-fn build_router(shared: SharedResources, resolver: Arc<AssetResolver<tauri::Wry>>) -> Router {
+/// An asset returned by the resolver: raw bytes + MIME type.
+pub struct Asset {
+    pub bytes: Vec<u8>,
+    pub mime_type: String,
+}
+
+/// A function that resolves a path to an asset.
+pub type SharedAssetResolver = Arc<dyn Fn(&str) -> Option<Asset> + Send + Sync>;
+
+fn build_router(shared: SharedResources, resolver: SharedAssetResolver) -> Router {
     let ws_state = WsState { resources: shared };
 
     Router::new()
@@ -25,7 +33,7 @@ fn build_router(shared: SharedResources, resolver: Arc<AssetResolver<tauri::Wry>
         })
 }
 
-fn serve_asset(resolver: &AssetResolver<tauri::Wry>, uri: Uri) -> Response {
+fn serve_asset(resolver: &SharedAssetResolver, uri: Uri) -> Response {
     let path = uri.path();
     let target = if path == "/" {
         "index.html"
@@ -38,8 +46,8 @@ fn serve_asset(resolver: &AssetResolver<tauri::Wry>, uri: Uri) -> Response {
         .unwrap_or_else(|| (StatusCode::NOT_FOUND, "Not Found").into_response())
 }
 
-fn resolve_asset(resolver: &AssetResolver<tauri::Wry>, path: &str) -> Option<Response> {
-    let asset = resolver.get(path.to_string())?;
+fn resolve_asset(resolver: &SharedAssetResolver, path: &str) -> Option<Response> {
+    let asset = resolver(path)?;
     let mut response = Response::new(Body::from(asset.bytes));
     if let Ok(ct) = HeaderValue::from_str(&asset.mime_type) {
         response.headers_mut().insert(header::CONTENT_TYPE, ct);
@@ -50,7 +58,7 @@ fn resolve_asset(resolver: &AssetResolver<tauri::Wry>, path: &str) -> Option<Res
 pub async fn serve_with_listener(
     listener: TcpListener,
     shared: SharedResources,
-    resolver: Arc<AssetResolver<tauri::Wry>>,
+    resolver: SharedAssetResolver,
 ) -> Result<()> {
     let router = build_router(shared, resolver);
     tracing::info!("HTTP server listening on http://{}", listener.local_addr()?);

koharu-runtime/Cargo.toml

@@ -12,7 +12,7 @@ keywords.workspace = true
 publish.workspace = true
 
 [dependencies]
-koharu-core = { workspace = true }
+koharu-http = { workspace = true }
 anyhow = { workspace = true }
 serde_json = { workspace = true }
 zip = { workspace = true }

koharu-runtime/src/dylib.rs

@@ -7,8 +7,8 @@ use std::{
 
 use anyhow::{Context, Result};
 use futures::stream::{self, StreamExt, TryStreamExt};
-use koharu_core::download;
-use koharu_core::http::http_client;
+use koharu_http::download;
+use koharu_http::http::http_client;
 use once_cell::sync::OnceCell;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use tokio::task;

koharu-runtime/src/zip.rs

@@ -2,7 +2,7 @@ use std::io;
 
 use anyhow::Result;
 use flate2::read::DeflateDecoder;
-use koharu_core::http::http_client;
+use koharu_http::http::http_client;
 
 // ZIP signatures and constants
 const SIG_EOCD: [u8; 4] = [0x50, 0x4b, 0x05, 0x06]; // End Of Central Directory

koharu-types/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "koharu-types"
+version.workspace = true
+edition.workspace = true
+description.workspace = true
+license.workspace = true
+authors.workspace = true
+readme.workspace = true
+homepage.workspace = true
+repository.workspace = true
+keywords.workspace = true
+publish.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+blake3 = { workspace = true }
+image = { workspace = true }
+serde = { workspace = true }
+serde_bytes = { workspace = true }
+sys-locale = { workspace = true }
+tokio = { workspace = true }

koharu-types/src/effect.rs

@@ -0,0 +1,25 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[derive(Default)]
+pub enum TextShaderEffect {
+    #[default]
+    Normal,
+    Antique,
+    Metal,
+    Manga,
+    MotionBlur,
+}
+
+impl TextShaderEffect {
+    pub fn id(self) -> f32 {
+        match self {
+            Self::Normal => 0.0,
+            Self::Antique => 1.0,
+            Self::Metal => 2.0,
+            Self::Manga => 3.0,
+            Self::MotionBlur => 4.0,
+        }
+    }
+}

koharu-types/src/font.rs

@@ -0,0 +1,45 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+pub enum TextDirection {
+    Horizontal,
+    Vertical,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NamedFontPrediction {
+    pub index: usize,
+    pub name: String,
+    pub language: Option<String>,
+    pub probability: f32,
+    pub serif: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FontPrediction {
+    pub top_fonts: Vec<(usize, f32)>,
+    pub named_fonts: Vec<NamedFontPrediction>,
+    pub direction: TextDirection,
+    pub text_color: [u8; 3],
+    pub stroke_color: [u8; 3],
+    pub font_size_px: f32,
+    pub stroke_width_px: f32,
+    pub line_height: f32,
+    pub angle_deg: f32,
+}
+
+impl Default for FontPrediction {
+    fn default() -> Self {
+        Self {
+            top_fonts: Vec::new(),
+            named_fonts: Vec::new(),
+            direction: TextDirection::Horizontal,
+            text_color: [0, 0, 0],
+            stroke_color: [0, 0, 0],
+            font_size_px: 0.0,
+            stroke_width_px: 0.0,
+            line_height: 1.0,
+            angle_deg: 0.0,
+        }
+    }
+}

{koharu → koharu-types}/src/image.rs

@@ -1,6 +1,6 @@
 use std::ops::Deref;
 
-use image::{ColorType, DynamicImage, codecs::webp::WebPEncoder};
+use ::image::{ColorType, DynamicImage, codecs::webp::WebPEncoder};
 use serde::{Deserialize, Serialize, Serializer};
 
 #[derive(Debug, Default, Clone)]
@@ -30,7 +30,7 @@ impl<'de> Deserialize<'de> for SerializableDynamicImage {
         D: serde::Deserializer<'de>,
     {
         let bytes: Vec<u8> = serde_bytes::deserialize(deserializer)?;
-        let img = image::load_from_memory(&bytes).map_err(serde::de::Error::custom)?;
+        let img = ::image::load_from_memory(&bytes).map_err(serde::de::Error::custom)?;
         Ok(SerializableDynamicImage(img))
     }
 }

koharu/src/state.rs → koharu-types/src/lib.rs

@@ -1,18 +1,18 @@
+mod effect;
+mod font;
+mod image;
+
+pub use effect::TextShaderEffect;
+pub use font::{FontPrediction, NamedFontPrediction, TextDirection};
+pub use image::SerializableDynamicImage;
+
 use std::{collections::HashSet, path::PathBuf, sync::Arc};
 
-use anyhow::anyhow;
-use image::GenericImageView;
-use koharu_ml::font_detector::FontPrediction;
-use koharu_renderer::renderer::TextShaderEffect;
+use ::image::GenericImageView;
 use serde::{Deserialize, Serialize};
 use sys_locale::get_locale;
 use tokio::sync::RwLock;
 
-use crate::{
-    image::SerializableDynamicImage,
-    khr::{deserialize_khr, has_khr_magic},
-};
-
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TextBlock {
@@ -188,22 +188,16 @@ impl Document {
         documents
             .into_iter()
             .next()
-            .ok_or_else(|| anyhow!("No document found in file"))
+            .ok_or_else(|| anyhow::anyhow!("No document found in file"))
     }
 
     pub fn from_bytes(path: impl Into<PathBuf>, bytes: Vec<u8>) -> anyhow::Result<Vec<Self>> {
         let path = path.into();
-
-        if has_khr_magic(&bytes) {
-            return deserialize_khr(&bytes)
-                .map_err(|err| anyhow!("Failed to load documents: {err}"));
-        }
-
         Ok(vec![Self::image(path, bytes)?])
     }
 
     fn image(path: PathBuf, bytes: Vec<u8>) -> anyhow::Result<Self> {
-        let img = image::load_from_memory(&bytes)?;
+        let img = ::image::load_from_memory(&bytes)?;
         let (width, height) = img.dimensions();
         let id = blake3::hash(&bytes).to_hex().to_string();
         let name = path

koharu/Cargo.toml

@@ -22,40 +22,24 @@ include = [
 ]
 
 [dependencies]
-koharu-core = { workspace = true }
 koharu-ml = { workspace = true }
+koharu-pipeline = { workspace = true }
 koharu-renderer = { workspace = true }
+koharu-rpc = { workspace = true }
 koharu-runtime = { workspace = true }
+koharu-types = { workspace = true }
 anyhow = { workspace = true }
-futures = { workspace = true }
+clap = { workspace = true }
+dirs = { workspace = true }
+git-version = { workspace = true }
+serde_json = { workspace = true }
+once_cell = { workspace = true }
 rfd = { workspace = true }
-open = { workspace = true }
-serde = { workspace = true }
-serde_bytes = { workspace = true }
-image = { workspace = true }
-tracing = { workspace = true }
-tracing-subscriber = { workspace = true }
-postcard = { workspace = true }
-thiserror = { workspace = true }
 tauri = { workspace = true }
 tauri-plugin-updater = { workspace = true }
-blake3 = { workspace = true }
 tokio = { workspace = true }
-rayon = { workspace = true }
-strum = { workspace = true }
-dirs = { workspace = true }
-clap = { workspace = true }
-once_cell = { workspace = true }
-sys-locale = { workspace = true }
-icu = { workspace = true }
-axum = { workspace = true }
-tower = { workspace = true }
-rmp-serde = { workspace = true }
-rmpv = { workspace = true }
-enum_dispatch = { workspace = true }
-async-trait = { workspace = true }
-git-version = { workspace = true }
-serde_json = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 windows = { workspace = true }

koharu/src/app.rs

@@ -2,21 +2,18 @@ use std::{path::PathBuf, sync::Arc};
 
 use anyhow::{Context, Result};
 use clap::Parser;
-use koharu_ml::{DeviceName, cuda_is_available, device_name};
-use koharu_runtime::{ensure_dylibs, preload_dylibs};
 use once_cell::sync::Lazy;
 use rfd::MessageDialog;
 use tauri::Manager;
 use tokio::{net::TcpListener, sync::RwLock};
 use tracing_subscriber::fmt::format::FmtSpan;
 
-use crate::{
-    llm, ml,
-    renderer::Renderer,
-    rpc::SharedResources,
-    server,
-    state::{AppState, State},
-};
+use koharu_ml::{cuda_is_available, device_name};
+use koharu_pipeline::AppResources;
+use koharu_renderer::facade::Renderer;
+use koharu_rpc::{SharedResources, server};
+use koharu_runtime::{ensure_dylibs, preload_dylibs};
+use koharu_types::State;
 
 static APP_ROOT: Lazy<PathBuf> = Lazy::new(|| {
     dirs::data_local_dir()
@@ -26,16 +23,6 @@ static APP_ROOT: Lazy<PathBuf> = Lazy::new(|| {
 static LIB_ROOT: Lazy<PathBuf> = Lazy::new(|| APP_ROOT.join("libs"));
 static MODEL_ROOT: Lazy<PathBuf> = Lazy::new(|| APP_ROOT.join("models"));
 
-#[derive(Clone)]
-pub struct AppResources {
-    pub state: AppState,
-    pub ml: Arc<ml::Model>,
-    pub llm: Arc<llm::Model>,
-    pub renderer: Arc<Renderer>,
-    pub ml_device: DeviceName,
-    pub pipeline: Arc<RwLock<Option<crate::pipeline::PipelineHandle>>>,
-}
-
 #[derive(Parser)]
 #[command(version = crate::version::APP_VERSION, about)]
 struct Cli {
@@ -117,7 +104,7 @@ fn initialize(headless: bool, _debug: bool) -> Result<()> {
 
 async fn prefetch() -> Result<()> {
     ensure_dylibs(LIB_ROOT.to_path_buf()).await?;
-    ml::prefetch().await?;
+    koharu_ml::facade::prefetch().await?;
 
     Ok(())
 }
@@ -146,11 +133,11 @@ async fn build_resources(cpu: bool) -> Result<AppResources> {
 
     let ml_device = device_name(cpu);
     let ml = Arc::new(
-        ml::Model::new(cpu)
+        koharu_ml::facade::Model::new(cpu)
             .await
             .context("Failed to initialize ML model")?,
     );
-    let llm = Arc::new(llm::Model::new(cpu));
+    let llm = Arc::new(koharu_ml::llm::facade::Model::new(cpu));
     let renderer = Arc::new(Renderer::new().context("Failed to initialize renderer")?);
     let state = Arc::new(RwLock::new(State::default()));
 
@@ -161,6 +148,7 @@ async fn build_resources(cpu: bool) -> Result<AppResources> {
         renderer,
         ml_device,
         pipeline: Arc::new(RwLock::new(None)),
+        version: crate::version::current(),
     })
 }
 
@@ -188,7 +176,14 @@ pub async fn run() -> Result<()> {
         .append_invoke_initialization_script(format!("window.__KOHARU_WS_PORT__ = {};", ws_port))
         .build(tauri::generate_context!())?;
 
-    let resolver = Arc::new(app.asset_resolver());
+    let tauri_resolver = Arc::new(app.asset_resolver());
+    let resolver: server::SharedAssetResolver = Arc::new(move |path: &str| {
+        let asset = tauri_resolver.get(path.to_string())?;
+        Some(server::Asset {
+            bytes: asset.bytes.to_vec(),
+            mime_type: asset.mime_type.clone(),
+        })
+    });
     tokio::spawn({
         let shared = shared.clone();
         async move {

koharu/src/khr.rs

@@ -1,144 +0,0 @@
-use std::io::Cursor;
-
-use anyhow::bail;
-use image::{DynamicImage, GenericImageView, ImageFormat, RgbaImage, imageops};
-use once_cell::sync::Lazy;
-
-use crate::state::Document;
-
-pub const KHR_MAGIC: &[u8; 4] = b"khr!";
-const KHR_FOOTER_LEN: usize = KHR_MAGIC.len() + std::mem::size_of::<u64>();
-const THUMBNAIL_HEIGHT: u32 = 300;
-const THUMBNAIL_WIDTH: u32 = THUMBNAIL_HEIGHT * 4 / 3; // 4:3 aspect for contact sheet
-const ICON_BYTES: &[u8] = include_bytes!("../icons/Square142x142Logo.png");
-
-static ICON_IMAGE: Lazy<RgbaImage> = Lazy::new(|| {
-    image::load_from_memory(ICON_BYTES)
-        .expect("failed to decode embedded icon")
-        .to_rgba8()
-});
-
-pub fn has_khr_magic(bytes: &[u8]) -> bool {
-    bytes.len() >= KHR_MAGIC.len() && &bytes[bytes.len() - KHR_MAGIC.len()..] == KHR_MAGIC
-}
-
-pub fn serialize_khr(documents: &[Document]) -> anyhow::Result<Vec<u8>> {
-    let thumbnail = thumbnail_contact_sheet(documents);
-    let mut thumbnail_bytes = Vec::new();
-    thumbnail.write_to(&mut Cursor::new(&mut thumbnail_bytes), ImageFormat::Jpeg)?;
-
-    let khr_bytes = postcard::to_allocvec(documents)?;
-    let khr_offset = thumbnail_bytes.len() as u64;
-
-    let mut output = thumbnail_bytes;
-    output.extend_from_slice(&khr_bytes);
-    output.extend_from_slice(&khr_offset.to_le_bytes());
-    output.extend_from_slice(KHR_MAGIC);
-
-    Ok(output)
-}
-
-pub fn deserialize_khr(bytes: &[u8]) -> anyhow::Result<Vec<Document>> {
-    if bytes.len() >= KHR_FOOTER_LEN && has_khr_magic(bytes) {
-        let offset_start = bytes.len() - KHR_FOOTER_LEN;
-        let offset_bytes: [u8; 8] = bytes[offset_start..offset_start + 8]
-            .try_into()
-            .expect("slice with exact length");
-        let khr_offset = u64::from_le_bytes(offset_bytes) as usize;
-        let khr_end = bytes.len() - KHR_FOOTER_LEN;
-
-        if khr_offset > khr_end {
-            bail!("Invalid KHR offset in file");
-        }
-
-        let khr_bytes = &bytes[khr_offset..khr_end];
-        return decode_postcard(khr_bytes);
-    }
-
-    // fallback to legacy format without footer/signature
-    decode_postcard(bytes)
-}
-
-fn decode_postcard(bytes: &[u8]) -> anyhow::Result<Vec<Document>> {
-    if let Ok(documents) = postcard::from_bytes(bytes) {
-        return Ok(documents);
-    }
-
-    let document: Document = postcard::from_bytes(bytes)?;
-    Ok(vec![document])
-}
-
-fn thumbnail_contact_sheet(documents: &[Document]) -> DynamicImage {
-    if documents.is_empty() {
-        return DynamicImage::new_rgba8(1, 1);
-    }
-
-    let mut canvas = RgbaImage::from_pixel(
-        THUMBNAIL_WIDTH,
-        THUMBNAIL_HEIGHT,
-        image::Rgba([255, 255, 255, 255]),
-    );
-
-    // If there's only one document, fill the entire canvas with it.
-    if documents.len() == 1 {
-        let thumb = documents[0]
-            .image
-            .thumbnail(THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT);
-        let (thumb_w, thumb_h) = thumb.dimensions();
-        let x = ((THUMBNAIL_WIDTH - thumb_w) / 2) as i64;
-        let y = ((THUMBNAIL_HEIGHT - thumb_h) / 2) as i64;
-        imageops::overlay(&mut canvas, &thumb.to_rgba8(), x, y);
-    } else {
-        // First image takes the left 1/3 of the canvas.
-        let left_width = THUMBNAIL_WIDTH / 3;
-        let first_thumb = documents[0].image.thumbnail(left_width, THUMBNAIL_HEIGHT);
-        let (first_w, first_h) = first_thumb.dimensions();
-        let first_x = ((left_width - first_w) / 2) as i64;
-        let first_y = ((THUMBNAIL_HEIGHT - first_h) / 2) as i64;
-        imageops::overlay(&mut canvas, &first_thumb.to_rgba8(), first_x, first_y);
-
-        // Remaining images are packed into the right 2/3 area.
-        let remaining = &documents[1..];
-        if !remaining.is_empty() {
-            let area_width = THUMBNAIL_WIDTH - left_width;
-            let area_height = THUMBNAIL_HEIGHT;
-
-            let cols = ((remaining.len() as f64).sqrt().ceil() as u32).max(1);
-            let rows = (remaining.len() as u32).div_ceil(cols);
-
-            let cell_w = (area_width / cols).max(1);
-            let cell_h = (area_height / rows).max(1);
-
-            for (idx, document) in remaining.iter().enumerate() {
-                let thumb = document.image.thumbnail(cell_w, cell_h);
-                let (thumb_w, thumb_h) = thumb.dimensions();
-
-                let col = (idx as u32) % cols;
-                let row = (idx as u32) / cols;
-
-                let base_x = left_width as i64 + (col * cell_w) as i64;
-                let base_y = (row * cell_h) as i64;
-                let x = base_x + ((cell_w as i64 - thumb_w as i64) / 2);
-                let y = base_y + ((cell_h as i64 - thumb_h as i64) / 2);
-
-                imageops::overlay(&mut canvas, &thumb.to_rgba8(), x, y);
-            }
-        }
-    }
-
-    // overlay small app icon on the bottom-left of the composite thumbnail
-    let icon = &*ICON_IMAGE;
-    let icon_w = icon.width() as i64;
-    let icon_h = icon.height() as i64;
-    let canvas_w = canvas.width() as i64;
-    let canvas_h = canvas.height() as i64;
-
-    if canvas_w >= icon_w && canvas_h >= icon_h {
-        let padding = 8i64;
-        let x = padding;
-        let y = (canvas_h - icon_h).max(0);
-        imageops::overlay(&mut canvas, icon, x, y);
-    }
-
-    DynamicImage::ImageRgba8(canvas)
-}

koharu/src/lib.rs

@@ -1,14 +1,4 @@
 pub mod app;
-pub mod image;
-pub mod khr;
-pub mod llm;
-pub mod ml;
-pub mod operations;
-pub mod pipeline;
-pub mod renderer;
-pub mod rpc;
-pub mod server;
-pub mod state;
 pub mod version;
 #[cfg(target_os = "windows")]
 pub mod windows;

koharu/src/rpc.rs

@@ -1,569 +0,0 @@
-use std::sync::Arc;
-use std::time::Duration;
-
-use anyhow::Result;
-use async_trait::async_trait;
-use axum::{
-    extract::{
-        State,
-        ws::{Message, WebSocket, WebSocketUpgrade},
-    },
-    response::IntoResponse,
-};
-use futures::{SinkExt, StreamExt};
-use serde::{Deserialize, Serialize};
-use tokio::sync::{broadcast, mpsc};
-use tower::{Service, ServiceBuilder, ServiceExt, service_fn, timeout::TimeoutLayer};
-
-use crate::app::AppResources;
-use crate::operations;
-
-// --- Shared Resources (lazy init) ---
-
-pub type SharedResources = Arc<tokio::sync::OnceCell<AppResources>>;
-
-// --- Wire Protocol ---
-
-#[derive(Debug, Deserialize)]
-struct RawIncoming {
-    id: u32,
-    method: String,
-    params: Option<rmpv::Value>,
-}
-
-#[derive(Debug, Serialize)]
-#[serde(tag = "type")]
-pub enum OutgoingMessage {
-    #[serde(rename = "res")]
-    Response {
-        id: u32,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        result: Option<rmpv::Value>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        error: Option<String>,
-    },
-    #[serde(rename = "ntf")]
-    Notification { method: String, params: rmpv::Value },
-}
-
-fn ok_response(id: u32, result: rmpv::Value) -> OutgoingMessage {
-    OutgoingMessage::Response {
-        id,
-        result: Some(result),
-        error: None,
-    }
-}
-
-fn err_response(id: u32, msg: &str) -> OutgoingMessage {
-    OutgoingMessage::Response {
-        id,
-        result: None,
-        error: Some(msg.to_string()),
-    }
-}
-
-// --- Value conversion helpers ---
-
-fn to_value<T: Serialize>(val: &T) -> Result<rmpv::Value> {
-    let bytes = rmp_serde::to_vec_named(val)?;
-    Ok(rmp_serde::from_slice(&bytes)?)
-}
-
-fn from_value<T: serde::de::DeserializeOwned>(val: rmpv::Value) -> Result<T> {
-    let bytes = rmp_serde::to_vec_named(&val)?;
-    Ok(rmp_serde::from_slice(&bytes)?)
-}
-
-// --- Handler Trait ---
-
-#[async_trait]
-#[enum_dispatch::enum_dispatch]
-pub trait RpcCall {
-    async fn call(self, res: AppResources) -> Result<rmpv::Value>;
-}
-
-// --- Handler Structs ---
-
-// No-param handlers
-
-#[derive(Deserialize)]
-pub struct AppVersionHandler;
-
-#[async_trait]
-impl RpcCall for AppVersionHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        let v = operations::app_version(state).await?;
-        to_value(&v)
-    }
-}
-
-#[derive(Deserialize)]
-pub struct DeviceHandler;
-
-#[async_trait]
-impl RpcCall for DeviceHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        let v = operations::device(state).await?;
-        to_value(&v)
-    }
-}
-
-#[derive(Deserialize)]
-pub struct GetDocumentsHandler;
-
-#[async_trait]
-impl RpcCall for GetDocumentsHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        let v = operations::get_documents(state).await?;
-        to_value(&v)
-    }
-}
-
-#[derive(Deserialize)]
-pub struct ListFontFamiliesHandler;
-
-#[async_trait]
-impl RpcCall for ListFontFamiliesHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        let v = operations::list_font_families(state).await?;
-        to_value(&v)
-    }
-}
-
-#[derive(Deserialize)]
-pub struct LlmListHandler;
-
-#[async_trait]
-impl RpcCall for LlmListHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        let v = operations::llm_list(state).await?;
-        to_value(&v)
-    }
-}
-
-#[derive(Deserialize)]
-pub struct LlmOffloadHandler;
-
-#[async_trait]
-impl RpcCall for LlmOffloadHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::llm_offload(state).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-#[derive(Deserialize)]
-pub struct LlmReadyHandler;
-
-#[async_trait]
-impl RpcCall for LlmReadyHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        let v = operations::llm_ready(state).await?;
-        to_value(&v)
-    }
-}
-
-#[derive(Deserialize)]
-pub struct SaveDocumentsHandler;
-
-#[async_trait]
-impl RpcCall for SaveDocumentsHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        let v = operations::save_documents(state).await?;
-        to_value(&v)
-    }
-}
-
-#[derive(Deserialize)]
-pub struct ProcessCancelHandler;
-
-#[async_trait]
-impl RpcCall for ProcessCancelHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::process_cancel(state).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-// Index-based handlers (wrapping IndexPayload)
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct GetDocumentHandler(operations::IndexPayload);
-
-#[async_trait]
-impl RpcCall for GetDocumentHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        let v = operations::get_document(state, self.0).await?;
-        to_value(&v)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct GetThumbnailHandler(operations::IndexPayload);
-
-#[async_trait]
-impl RpcCall for GetThumbnailHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        let v = operations::get_thumbnail(state, self.0).await?;
-        to_value(&v)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct ExportDocumentHandler(operations::IndexPayload);
-
-#[async_trait]
-impl RpcCall for ExportDocumentHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        let v = operations::export_document(state, self.0).await?;
-        to_value(&v)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct DetectHandler(operations::IndexPayload);
-
-#[async_trait]
-impl RpcCall for DetectHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::detect(state, self.0).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct OcrHandler(operations::IndexPayload);
-
-#[async_trait]
-impl RpcCall for OcrHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::ocr(state, self.0).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct InpaintHandler(operations::IndexPayload);
-
-#[async_trait]
-impl RpcCall for InpaintHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::inpaint(state, self.0).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-// Complex payload handlers
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct OpenExternalHandler(operations::OpenExternalPayload);
-
-#[async_trait]
-impl RpcCall for OpenExternalHandler {
-    async fn call(self, _state: AppResources) -> Result<rmpv::Value> {
-        operations::open_external(self.0)?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct OpenDocumentsHandler(operations::OpenDocumentsPayload);
-
-#[async_trait]
-impl RpcCall for OpenDocumentsHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        let v = operations::open_documents(state, self.0).await?;
-        to_value(&v)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct UpdateInpaintMaskHandler(operations::UpdateInpaintMaskPayload);
-
-#[async_trait]
-impl RpcCall for UpdateInpaintMaskHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::update_inpaint_mask(state, self.0).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct UpdateBrushLayerHandler(operations::UpdateBrushLayerPayload);
-
-#[async_trait]
-impl RpcCall for UpdateBrushLayerHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::update_brush_layer(state, self.0).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct InpaintPartialHandler(operations::InpaintPartialPayload);
-
-#[async_trait]
-impl RpcCall for InpaintPartialHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::inpaint_partial(state, self.0).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct RenderHandler(operations::RenderPayload);
-
-#[async_trait]
-impl RpcCall for RenderHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::render(state, self.0).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct UpdateTextBlocksHandler(operations::UpdateTextBlocksPayload);
-
-#[async_trait]
-impl RpcCall for UpdateTextBlocksHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::update_text_blocks(state, self.0).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct LlmLoadHandler(operations::LlmLoadPayload);
-
-#[async_trait]
-impl RpcCall for LlmLoadHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::llm_load(state, self.0).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct LlmGenerateHandler(operations::LlmGeneratePayload);
-
-#[async_trait]
-impl RpcCall for LlmGenerateHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::llm_generate(state, self.0).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(transparent)]
-pub struct ProcessHandler(crate::pipeline::ProcessRequest);
-
-#[async_trait]
-impl RpcCall for ProcessHandler {
-    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
-        operations::process(state, self.0).await?;
-        Ok(rmpv::Value::Nil)
-    }
-}
-
-// --- Method Dispatch Enum ---
-
-#[derive(Deserialize)]
-#[serde(tag = "method", content = "params")]
-#[enum_dispatch::enum_dispatch(RpcCall)]
-pub enum Method {
-    #[serde(rename = "app_version")]
-    AppVersion(AppVersionHandler),
-    #[serde(rename = "device")]
-    Device(DeviceHandler),
-    #[serde(rename = "open_external")]
-    OpenExternal(OpenExternalHandler),
-    #[serde(rename = "get_documents")]
-    GetDocuments(GetDocumentsHandler),
-    #[serde(rename = "get_document")]
-    GetDocument(GetDocumentHandler),
-    #[serde(rename = "get_thumbnail")]
-    GetThumbnail(GetThumbnailHandler),
-    #[serde(rename = "open_documents")]
-    OpenDocuments(OpenDocumentsHandler),
-    #[serde(rename = "save_documents")]
-    SaveDocuments(SaveDocumentsHandler),
-    #[serde(rename = "export_document")]
-    ExportDocument(ExportDocumentHandler),
-    #[serde(rename = "detect")]
-    Detect(DetectHandler),
-    #[serde(rename = "ocr")]
-    Ocr(OcrHandler),
-    #[serde(rename = "inpaint")]
-    Inpaint(InpaintHandler),
-    #[serde(rename = "update_inpaint_mask")]
-    UpdateInpaintMask(UpdateInpaintMaskHandler),
-    #[serde(rename = "update_brush_layer")]
-    UpdateBrushLayer(UpdateBrushLayerHandler),
-    #[serde(rename = "inpaint_partial")]
-    InpaintPartial(InpaintPartialHandler),
-    #[serde(rename = "render")]
-    Render(RenderHandler),
-    #[serde(rename = "update_text_blocks")]
-    UpdateTextBlocks(UpdateTextBlocksHandler),
-    #[serde(rename = "list_font_families")]
-    ListFontFamilies(ListFontFamiliesHandler),
-    #[serde(rename = "llm_list")]
-    LlmList(LlmListHandler),
-    #[serde(rename = "llm_load")]
-    LlmLoad(LlmLoadHandler),
-    #[serde(rename = "llm_offload")]
-    LlmOffload(LlmOffloadHandler),
-    #[serde(rename = "llm_ready")]
-    LlmReady(LlmReadyHandler),
-    #[serde(rename = "llm_generate")]
-    LlmGenerate(LlmGenerateHandler),
-    #[serde(rename = "process")]
-    Process(ProcessHandler),
-    #[serde(rename = "process_cancel")]
-    ProcessCancel(ProcessCancelHandler),
-}
-
-/// Parse method name + params into a Method enum using serde adjacently-tagged deserialization.
-fn parse_call(method: &str, params: rmpv::Value) -> Result<Method> {
-    let tagged = rmpv::Value::Map(vec![
-        (
-            rmpv::Value::String("method".into()),
-            rmpv::Value::String(method.into()),
-        ),
-        (rmpv::Value::String("params".into()), params),
-    ]);
-    from_value(tagged)
-}
-
-// --- WebSocket State ---
-
-#[derive(Clone)]
-pub struct WsState {
-    pub resources: SharedResources,
-}
-
-// --- WebSocket Handler ---
-
-pub async fn ws_handler(ws: WebSocketUpgrade, State(state): State<WsState>) -> impl IntoResponse {
-    ws.max_message_size(1024 * 1024 * 1024)
-        .on_upgrade(|socket| handle_socket(socket, state))
-}
-
-async fn handle_socket(socket: WebSocket, state: WsState) {
-    let (mut ws_sender, mut ws_receiver) = socket.split();
-    let (tx, mut send_rx) = mpsc::channel::<OutgoingMessage>(256);
-
-    // Notification forwarders
-    spawn_notification_forwarder(
-        "download_progress",
-        koharu_core::download::subscribe(),
-        tx.clone(),
-    );
-    spawn_notification_forwarder("process_progress", crate::pipeline::subscribe(), tx.clone());
-
-    // Sender task: drain mpsc → WebSocket binary frames
-    let send_task = tokio::spawn(async move {
-        while let Some(msg) = send_rx.recv().await {
-            let Ok(bytes) = rmp_serde::to_vec_named(&msg) else {
-                continue;
-            };
-            if ws_sender.send(Message::Binary(bytes.into())).await.is_err() {
-                break;
-            }
-        }
-    });
-
-    // Tower dispatch service (cloned per request)
-    let dispatch_svc = ServiceBuilder::new()
-        .layer(TimeoutLayer::new(Duration::from_secs(300)))
-        .service(service_fn(
-            |(method, res): (Method, AppResources)| async move { method.call(res).await },
-        ));
-
-    // Receive loop
-    while let Some(Ok(msg)) = ws_receiver.next().await {
-        let data = match msg {
-            Message::Binary(data) => data,
-            Message::Close(_) => break,
-            _ => continue,
-        };
-
-        let raw: RawIncoming = match rmp_serde::from_slice(&data) {
-            Ok(r) => r,
-            Err(e) => {
-                let _ = tx
-                    .send(err_response(0, &format!("Decode error: {e}")))
-                    .await;
-                continue;
-            }
-        };
-
-        let id = raw.id;
-        let tx = tx.clone();
-        let resources = state.resources.clone();
-        let mut svc = dispatch_svc.clone();
-
-        tokio::spawn(async move {
-            let response = match resources.get() {
-                Some(res) => {
-                    let params = raw.params.unwrap_or(rmpv::Value::Nil);
-                    match parse_call(&raw.method, params) {
-                        Ok(method) => match svc.ready().await {
-                            Ok(ready) => match ready.call((method, res.clone())).await {
-                                Ok(result) => ok_response(id, result),
-                                Err(e) => err_response(id, &format!("{e:#}")),
-                            },
-                            Err(e) => err_response(id, &format!("{e}")),
-                        },
-                        Err(e) => err_response(id, &format!("{e:#}")),
-                    }
-                }
-                None => err_response(id, "Resources not initialized"),
-            };
-            let _ = tx.send(response).await;
-        });
-    }
-
-    send_task.abort();
-}
-
-fn spawn_notification_forwarder<T: Serialize + Clone + Send + 'static>(
-    method: &'static str,
-    mut rx: broadcast::Receiver<T>,
-    tx: mpsc::Sender<OutgoingMessage>,
-) {
-    tokio::spawn(async move {
-        loop {
-            match rx.recv().await {
-                Ok(payload) => {
-                    let params = to_value(&payload).unwrap_or(rmpv::Value::Nil);
-                    let msg = OutgoingMessage::Notification {
-                        method: method.to_string(),
-                        params,
-                    };
-                    if tx.send(msg).await.is_err() {
-                        break;
-                    }
-                }
-                Err(broadcast::error::RecvError::Lagged(_)) => continue,
-                Err(broadcast::error::RecvError::Closed) => break,
-            }
-        }
-    });
-}